Les exemples de cet article décrivent l'utilisation de la gestion des exceptions Java. Partagez-le avec tout le monde pour votre référence. L’analyse spécifique est la suivante :
Le mécanisme de gestion des exceptions de Java peut nous aider à éviter ou à gérer les erreurs qui peuvent survenir dans le programme, afin que le programme ne se termine pas de manière inattendue lorsqu'il rencontre des erreurs récupérables, mais à gérer ces erreurs, ce qui nous rend également meilleurs dans l'écriture de programmes. besoin d'écrire beaucoup de code pour vérifier les conditions d'erreur, ce qui améliore la lisibilité et la logique du code. En Java, une exception représente un objet entité incorrect.
Les exceptions peuvent être divisées en deux catégories : l'une concerne les erreurs graves, telles que les erreurs matérielles, la mémoire insuffisante, etc., qui correspondent à la classe Error et à ses sous-classes du package java.lang. Habituellement, ce type de programme d'erreur lui-même ne peut pas être récupéré et doit interrompre l'exécution du programme ; l'autre type est constitué d'erreurs non graves, telles que l'utilisateur saisissant des données illégales, divisant par 0, etc. Ils correspondent à la classe Exception et Ses exceptions dans le package java.lang Sous-classe, ce type d'erreur peut généralement être récupéré sans affecter le fonctionnement du programme.
Nous pouvons utiliser les mots-clés try, catch et enfin pour détecter les exceptions.
1. essayer, attraper
Placez les instructions susceptibles de provoquer des exceptions dans le bloc try{}, puis interceptez-les dans le bloc d'instructions catch{}. Exception si divisé par 0 :
public class SimpleDemo { //Opération de division public static int devision(int a,int b) { return a / b; public static void main(String[] args) { try { //5 divisé par 0 SimpleDemo.devision(5 ,0); System.out.println("Exception"); } catch (Exception e) { e.printStackTrace(); } System.out.println("Terminer" } }Résultat de l'exécution :
Comme vous pouvez le voir, Finish est imprimé, indiquant que le programme ne s'est pas terminé en raison d'une erreur de division par 0.
Dans le même temps, nous avons également constaté que l'instruction System.out.println sous SimpleDemo.devision() où l'exception s'est produite n'était pas exécutée. Une fois qu'une exception se produit, le programme sortira de la position d'exécution actuelle sans exécuter les instructions suivant l'exception.
2. enfin
Les instructions du bloc final seront exécutées, qu'une exception se produise ou non.
Quelqu'un pourrait se demander, puisque les instructions du bloc final seront exécutées indépendamment du fait qu'une exception se produise, alors quel en est l'effet pratique finalement ? Je ne peux pas l'écrire directement dehors sans finalement ?
Comme dans l'exemple ci-dessus, nous ajoutons un return au bloc d'instruction catch :
public class SimpleDemo { //Opération de division public static int division(int a,int b) { return a / b; public static void main(String[] args) { try { //5 divisé par 0 SimpleDemo.division(5 ,0); System.out.println("Exception"); } catch (Exception e) { e.printStackTrace(); //la fonction principale renvoie} enfin { System.out.println("Enfin"); } System.out.println("Terminer" } }À ce stade, la finition à l'extérieur du bloc final n'est pas imprimée, mais la fin à l'intérieur du bloc final est imprimée.
est finalement très utile dans le développement réel. Par exemple, si nous ouvrons une base de données et qu'une exception se produit lors de la lecture et de l'écriture de données dans la base de données, nous devons alors fermer la connexion à la base de données et libérer les ressources correspondantes. À ce stade, il est plus approprié d'écrire le code pour libérer les ressources dans le bloc final.
Mais il convient de noter que le bloc final ne sera pas exécuté dans un seul cas. Si le programme se termine avant d'exécuter le bloc final, par exemple en appelant la méthode System.exit(), le bloc final n'aura pas la possibilité de s'exécuter.
3. Lancez une exception
Si une exception se produit dans une méthode, mais que nous ne voulons pas gérer l'exception directement dans la méthode, mais que nous voulons que l'appelant de la méthode la gère, nous pouvons utiliser le mot-clé throws pour déclarer cette méthode pour lever l'exception. Ceci est très courant dans les fonctions API fournies par Sun. Par exemple, la méthode read dans java.io.Reader est déclarée pour lever une IOException :
public int read(char[] cbuf) lance IOException
À ce stade, lorsque nous appelons la méthode read, nous devons la mettre dans le bloc d'instructions try pour intercepter les exceptions, sinon le compilateur signalera une erreur et nous forcera à intercepter les exceptions.
Bien sûr, si nous ne voulons vraiment pas gérer les exceptions lors de l'appel de read, nous pouvons également déclarer la méthode qui appelle la méthode read comme lançant IOException, afin que l'exception soit à nouveau levée. Si nous déclarons une exception dans la fonction principale, les informations d'exception seront finalement capturées et traitées par la JVM, et le résultat du traitement de la JVM consiste à imprimer les informations d'exception, puis à terminer le programme.
4. Structure de gestion des exceptions
Toutes les classes d'exception sont dérivées de la classe Exception. Cela signifie que si nous ne sommes pas sûrs du type d'exception qui se produira, nous pouvons directement déclarer un objet Exception dans catch pour intercepter toutes les exceptions de la classe Exception et de ses sous-classes. Mais faites attention à l'ordre dans lequel catch est écrit. S'il y a plusieurs captures après un essai et que la première capture déclare un objet Exception, alors l'exception sera gérée directement par la première capture et les captures suivantes ne pourront pas intercepter cette exception. Ce genre d'erreur générera une erreur lors de la compilation. Par exemple:
public class CatchDemo { //Opération de division public static int division(int a,int b) { return a / b; } public static void main(String[] args) { try { CatchDemo.division(4,0 } catch); (Exception e) { System.out.println("Classe d'exception"); } catch(ArithmeticException e) { System.out.println("Classe ArithmeticException"); } } }Le compilateur indique qu'ArithmeticException a été interceptée, ce qui signifie que l'exception ci-dessus a intercepté cette exception et qu'il n'est pas nécessaire de l'attraper à nouveau.
Que se passerait-il si ces deux captures étaient inversées ?
public class CatchDemo { //Opération de division public static int division(int a,int b) { return a / b; } public static void main(String[] args) { try { CatchDemo.division(4,0 } catch); (ArithmeticException e) { System.out.println("Classe ArithmeticException"); } catch(Exception e) { System.out.println("Classe d'exception"); } } }À ce moment-là, nous avons constaté que le code avait réussi la compilation et que le résultat de l'exécution était qu'ArithmeticException avait intercepté cette exception, mais que l'interception suivante ne l'avait pas interceptée.
J'espère que cet article sera utile à la programmation Java de chacun.