1. Introduction
Essayez… Catch… enfin est probablement une phrase que tout le monde connaît, et cela semble très simple à utiliser, et il semble logiquement facile à comprendre. Cependant, "l'apprentissage" que je me suis expérimenté m'a dit personnellement que cette chose n'était pas aussi simple et obéissante que je l'imaginais. Vous ne le croyez pas? Ensuite, regardez le code ci-dessous, quel sera le résultat après son exécution? Ne regardez pas les réponses à l'envers, et vous n'autorisez pas le code à être exécuté pour voir les vraies réponses. Si votre réponse est correcte, vous n'avez pas à perdre de temps à lire cet article.
test de package; classe publique TestException {public TestException () {} boolean testEx () lève l'exception {boolean ret = true; essayez {ret = testEx1 (); } catch (exception e) {System.out.println ("TestEx, Catch Exception"); ret = false; jeter e; } enfin {System.out.println ("TestEx, enfin; return value =" + ret); return ret; }} boolean testEx1 () lève une exception {booléen ret = true; essayez {ret = testEx2 (); if (! ret) {return false; } System.out.println ("TestEx1, à la fin de l'essai"); return ret; } catch (exception e) {System.out.println ("TestEx1, Catch Exception"); ret = false; jeter e; } enfin {System.out.println ("TestEx1, enfin; return value =" + ret); return ret; }} boolean testEx2 () lève une exception {booléen ret = true; essayez {int b = 12; INT C; pour (int i = 2; i> = -2; i--) {c = b / i; System.out.println ("i =" + i); } return true; } catch (exception e) {System.out.println ("TestEx2, Catch Exception"); ret = false; jeter e; } enfin {System.out.println ("TestEx2, enfin; return value =" + ret); return ret; }} public static void main (String [] args) {TestException TestException1 = new TestException (); essayez {TestException1.Testex (); } catch (exception e) {e.printStackTrace (); }}} Quelle est votre réponse? Est-ce la réponse ci-dessous?
i = 2
i = 1
TestEx2, Catch Exception
TestEx2, enfin; valeur de retour = false
TestEx1, Catch Exception
TestEx1, enfin; valeur de retour = false
TestEx, Catch Exception
TestEx, enfin; valeur de retour = false
Si votre réponse est vraiment mentionnée ci-dessus, vous vous trompez. ^ _ ^, alors je vous suggère de lire attentivement cet article ou d'utiliser le code ci-dessus pour modifier, exécuter et tester en fonction de diverses situations. Vous constaterez qu'il y a beaucoup de choses qui ne sont pas aussi simples que l'imaginaire à l'origine. Publiez maintenant la bonne réponse:
i = 2
i = 1
TestEx2, Catch Exception
TestEx2, enfin; valeur de retour = false
TestEx1, enfin; valeur de retour = false
TestEx, enfin; valeur de retour = false
Note:
Enfin, le bloc d'instruction ne doit pas apparaître, le retour doit apparaître. Le retour RET ci-dessus est de préférence une autre instruction pour gérer la logique pertinente.
2. Exception Java
Les exceptions se réfèrent à diverses situations qui se produisent de façon inattendue, telles que: fichier introuvable, défaillance de la connexion réseau, paramètres illégaux, etc. Une exception est un événement qui se produit pendant l'exécution du programme et interfère avec le flux d'instructions normal. Java décrit diverses exceptions à travers de nombreuses sous-classes de la classe jetable de l'API. Par conséquent, les exceptions Java sont des objets, des instances de sous-classes jetables, décrivant des conditions d'erreur qui apparaissent dans un codage. Lorsqu'une condition est générée, une erreur lancera une exception.
Diagramme de hiérarchie de classe Java Exception:
Figure 1 Diagramme de hiérarchie des classes d'exception Java
En Java, toutes les exceptions ont un ancêtre commun, jetable (jetable). Throwable Spécifie le point commun de tout problème qui peut être transmis via des applications Java dans le code par des mécanismes de propagation des exceptions.
Thingable: il y a deux sous-classes importantes: l'exception et l'erreur. Les deux sont des sous-classes importantes pour la manipulation des exceptions Java, et chacune contient un grand nombre de sous-classes.
Erreur: une erreur que le programme ne peut pas gérer, indiquant un problème grave dans l'exécution de l'application. La plupart des erreurs ne sont pas liées aux actions effectuées par l'écrivain de code, mais représentent des problèmes avec JVM (Java Virtual Machine) lorsque le code est exécuté. Par exemple, une machine virtuelle Java exécute une erreur (Virtual MachineError), et une OutOfMemoryError apparaît lorsque le JVM n'a plus les ressources de mémoire nécessaires pour poursuivre l'opération. Lorsque ces exceptions se produisent, la machine virtuelle Java (JVM) choisit généralement de terminer les threads.
Ces erreurs indiquent que la défaillance se produit lorsque la machine virtuelle elle-même, ou lorsque la machine virtuelle essaie d'exécuter l'application, telle qu'une erreur de course à la machine virtuelle Java (Machineror virtuelle), une erreur de définition de classe (NoclassdeffoundError), etc. Ces erreurs sont indétectables car elles ne sont pas autorisées à se produire lorsque le programme est en cours. Pour une application bien conçue, même si une erreur se produit, elle ne devrait pas essayer essentiellement de gérer les exceptions qu'elle provoque. Dans Java, l'erreur est décrite par une sous-classe d'erreur.
Exception: une exception que le programme lui-même peut gérer.
La classe d'exception a une sous-classe importante, RuntimeException. La classe RuntimeException et ses sous-classes représentent une erreur soulevée par les "opérations JVM communes". Par exemple, si vous essayez d'utiliser une référence d'objet nulle, un diviseur zéro ou un tableau hors limites, une exception d'exécution (nullpointerException, arithmeticexception) et ArrayIndexoutofboundException sont respectivement soulevées.
Remarque: La différence entre les exceptions et les erreurs: les exceptions peuvent être gérées par le programme lui-même, mais les erreurs ne peuvent pas être gérées.
Généralement, les exceptions Java (y compris les exceptions et les erreurs) sont divisées en exceptions vérifiées et des exceptions non contrôlées.
Des exceptions peuvent être vérifiées (exceptions qui doivent être gérées par le compilateur): il est facile de se produire et des exceptions raisonnables et tolérantes lorsque le programme correct est en cours d'exécution. Bien que l'exception vérifiable soit une condition anormale, son occurrence est prévisible dans une certaine mesure, et une fois qu'une telle condition anormale se produit, elle doit être gérée d'une manière ou d'une autre.
À l'exception de RuntimeException et de ses sous-classes, d'autres classes d'exception et leurs sous-classes sont toutes des exceptions vérifiables. La caractéristique de cette exception est que le compilateur Java le vérifiera, c'est-à-dire qu'une telle exception peut se produire dans le programme, soit l'attraper avec l'instruction TRYPACCH ou le lancer avec la clause Luts, sinon la compilation ne passera pas.
Exceptions inédites (exceptions selon lesquelles le compilateur ne nécessite pas d'élimination forcée): y compris les exceptions d'exécution (RuntimeException et ses sous-classes) et les erreurs (erreur).
Exception Cette exception est divisée en deux catégories: exception d'exécution et exception sans traduit (exception de compilation). Ces exceptions devraient être traitées autant que possible dans le programme.
Exceptions d'exécution: ils sont tous la classe RuntimeException et ses exceptions de sous-classe, telles que NullPointerException (exception du pointeur nul), IndexoutofBoundSexception (exception hors limites), etc. Ces exceptions ne vérifient pas les exceptions, et vous pouvez choisir de les capturer et de les traiter dans le programme, ou vous ne pouvez pas les gérer. Ces exceptions sont généralement causées par les erreurs de logique du programme, et les programmes devraient éviter de telles exceptions autant que possible dans une perspective logique.
La caractéristique de l'exception d'exécution est que le compilateur Java ne le vérifiera pas. C'est-à-dire que lorsqu'une telle exception peut se produire dans le programme, même si elle n'est pas capturée avec l'instruction TRY-Catch et lancée avec la clause Luts, elle sera compilée et adoptée.
Exception non-runtime (exception de compilation): est une exception autre que RuntimeException, et appartient à la classe d'exception et à ses sous-classes en termes de type. Du point de vue de la syntaxe du programme, il s'agit d'une exception qui doit être traitée. S'il n'est pas traité, le programme ne peut pas être compilé et réussi. Tels que ioException, sqlexception, etc., et des exceptions d'exceptions définies par l'utilisateur, en général, aucune exception de vérification personnalisée n'est vérifiée.
3. Mécanisme de gestion des exceptions
Dans les applications Java, le mécanisme de gestion des exceptions est: lancer des exceptions et capturer des exceptions.
Jetez une exception: lorsqu'une erreur se produit dans une méthode et soulève une exception, la méthode crée un objet d'exception et le livre au système d'exécution. L'objet d'exception contient des informations d'exception telles que le type d'exception et l'état du programme lorsque l'exception se produit. Le système d'exécution est responsable de la recherche et de l'exécution du code pour gérer les exceptions.
Catch Exception: Une fois que la méthode a lancé une exception, le système d'exécution sera tourné vers la recherche d'un gestionnaire d'exceptions approprié. Un gestionnaire d'exceptions potentiels est une collection de méthodes qui restent dans la pile d'appels à leur tour lorsqu'une exception se produit. Lorsque le type d'exception que le processeur d'exception peut gérer est cohérent avec le type d'exception lancé par la méthode, il s'agit d'un processeur d'exception approprié. Le système d'exécution commence par la méthode où une exception se produit, puis regarde les méthodes de la pile d'appels à son tour jusqu'à ce qu'elle trouve une méthode contenant un gestionnaire d'exceptions approprié et l'exécute. Lorsque le système d'exécution traverse la pile d'appels et ne trouve pas de gestionnaire d'exceptions approprié, le système d'exécution se termine. Dans le même temps, cela signifie la résiliation du programme Java.
Pour les exceptions d'exécution, les erreurs ou les exceptions détectables, les méthodes de traitement des exceptions requises par Java Technology sont différentes.
En raison des exceptions d'exécution indétectables, afin d'implémenter l'application plus raisonnablement et facilement, Java stipule que les exceptions d'exécution seront automatiquement lancées par le système d'exécution Java, permettant à l'application d'ignorer les exceptions d'exécution.
Pour les erreurs qui peuvent se produire pendant le fonctionnement de la méthode, Java permet à la méthode de ne lancer aucune déclaration lorsque la méthode ne doit pas être capturée. Étant donné que la plupart des exceptions d'erreur sont des situations qui ne peuvent jamais se produire, et sont également des exceptions que les applications raisonnables ne devraient pas attraper.
Pour toutes les exceptions vérifiables, Java stipule qu'une méthode doit être capturée ou déclarée en dehors de la méthode de lancer. Autrement dit, lorsqu'une méthode choisit de ne pas prendre une exception véritable, elle doit déclarer que l'exception sera lancée.
Une méthode qui peut prendre des exceptions nécessite de fournir un type de gestionnaire d'exceptions correspondant. L'exception capturée peut être causée par une exception soulevée et lancée par sa propre déclaration, ou une exception lancée par une méthode appelée ou un système d'exécution Java, etc. En d'autres termes, l'exception qu'une méthode peut attraper doit être une exception lancée par le code Java quelque part. Autrement dit, les exceptions sont toujours jetées en premier puis prises.
Tout code Java peut lancer des exceptions, telles que: code écrit par vous-même, code du package de l'environnement de développement Java ou système d'exécution Java. Peu importe de qui il s'agit, vous pouvez lancer une exception à travers la déclaration Java Throw.
Toute exception projetée à partir de la méthode doit être utilisée avec la clause des lancers.
Les exceptions de capture sont obtenues grâce à des instructions de capture d'essai ou à des instructions de capture d'essai.
De manière générale, Java stipule que les exceptions vérifiables doivent être prises ou déclarées lancées. Permet d'ignorer RuntimeException et d'erreur non cochées.
3.1 Catch Exceptions: Essayez, attrapez et enfin
1. Déclaration de match-match
En Java, des exceptions sont prises par une déclaration de couple d'essai. Sa forme de syntaxe générale est:
Try {// Code de programme où les exceptions peuvent se produire} catch (type1 id1) {// capture et gérez le type d'exception lancé par try type1} catch (type2 id2) {// capture et traitez le type d'exception lancé par essai type2}Une paire d'accès après le mot clé Essaye enveloppe un morceau de code qui peut avoir une exception, qui est appelé une zone de surveillance. Si une exception se produit pendant la méthode Java pendant l'exécution, un objet d'exception est créé. Jetez l'exception à l'extérieur de la zone de surveillance, et le système d'exécution Java essaie de trouver une clause de capture assortie pour attraper l'exception. S'il y a une clause de capture correspondante, exécutez son code de gestion des exceptions et que l'instruction TRY-Catch se termine.
Le principe de l'appariement est: si l'objet d'exception lancé appartient à la classe d'exception de la clause Catch ou appartient à une sous-classe de la classe d'exception, il est considéré que l'objet d'exception généré correspond au type d'exception capturé par le bloc de capture.
Exemple 1 Catch l'exception "Dividter is 0" lancé par l'instruction Throw.
classe publique TestException {public static void main (String [] args) {int a = 6; int b = 0; Essayez {// essayez la zone de surveillance si (b == 0) lance un nouveau arithmeticexception (); // lancer une exception via la déclaration de lancer System.out.println ("La valeur de A / B est:" + a / b); } catch (arithmeticexception e) {// catch catch exception system.out.println ("Le programme a une exception, et la variable B ne peut pas être 0."); } System.out.println ("Le programme se termine normalement."); }}Résultat en cours: le programme a une exception et la variable B ne peut pas être 0.
Le programme se termine normalement.
Exemple 1 Dans la zone de surveillance d'essai, utilisez la déclaration si pour juger. Lorsque la condition d'erreur de "Divider est 0" est établie, une exception ArithMeticexception est créée et l'instruction Throw lance l'exception au système d'exécution Java. Le système trouve une capture de gestionnaire d'exception correspondante et exécute le code de gestion des exceptions correspondant. Imprimez "Le programme a une exception et la variable B ne peut pas être 0." L'instruction TRY-Catch se termine et continue le flux du programme.
En fait, ArithMeticexception telle que "Divider is 0" est une sous-classe de RunTimexception. L'exception d'exécution sera automatiquement lancée par le système d'exécution, et il n'est pas nécessaire d'utiliser une instruction Throw.
Exemple 2: Catch l'exception Arithmeticexception causée par le "Divider est 0" qui lance automatiquement pendant le système d'exécution.
public static void main (String [] args) {int a = 6; int b = 0; essayez {System.out.println ("La valeur de A / B est:" + a / b); } catch (arithmeticexception e) {System.out.println ("Le programme a une exception, et la variable B ne peut pas être 0."); } System.out.println ("Le programme se termine normalement."); }}Résultat en cours: le programme a une exception et la variable B ne peut pas être 0.
Le programme se termine normalement.
Déclaration dans l'exemple 2:
System.out.println ("La valeur de A / B est:" + a / b);Une erreur de "Divider est 0" a été générée pendant l'exécution, et une exception ArithMeticexception a été soulevée. Le système d'exécution crée un objet d'exception et lance une zone de surveillance, correspond plutôt à la capture de gestionnaire d'exceptions appropriée et exécute le code de gestion des exceptions correspondant.
Étant donné que le coût de la vérification des exceptions d'exécution est beaucoup plus élevé que les avantages de la capture des exceptions, les exceptions d'exécution ne peuvent pas être détectées. Le compilateur Java permet d'ignorer les exceptions d'exécution, et une méthode ne peut ni attraper ni déclarer des exceptions d'exécution.
Exemple 3: pas de prise ou déclarer que l'exception d'exécution est lancée.
classe publique TestException {public static void main (String [] args) {int a, b; a = 6; b = 0; // La valeur du diviseur B est 0 System.out.println (a / b); }}Résultats en cours:
Exception dans Thread "Main" java.lang.arithmeticexception: / par zéro
à test.testException.main (TestException.java:8)
Exemple 4 Le programme peut avoir une exception du diviseur 0 et une exception de l'indice du tableau hors limites.
classe publique TestException {public static void main (String [] args) {int [] intArray = new int [3]; essayez {pour (int i = 0; i <= intarray.length; i ++) {intarray [i] = i; System.out.println ("IntArray [" + i + "] =" + intArray [i]); System.out.println ("IntArray [" + i + "] Module" + (i - 2) + "valeurs:" + intarray [i]% (i - 2)); }} catch (arrayIndexoutofBoundSexception e) {System.out.println ("IntaRray Array Indice-Out-of-Bounds Exception."); } catch (arithmeticexception e) {System.out.println ("Exception du diviseur 0."); } System.out.println ("Le programme se termine normalement."); }}Résultats en cours:
intarray [0] = 0
IntaRray [0] MODULE-2 Valeur: 0
intarray [1] = 1
La valeur d'intarray [1] modulo-1: 0
intarray [2] = 2
Exception du diviseur 0.
Le programme se termine normalement.
Exemple 5 Le programme peut ressentir une exception du diviseur 0, et une exception des indices de tableau peut également se produire. Pendant le programme du programme, le type d'exception ArithMeticexception correspond d'abord, donc l'instruction Catch est exécutée:
Catch (arithmeticexception e) {System.out.println ("Exception du diviseur 0."); }Il convient de noter qu'une fois qu'une capture de capture attrape le type d'exception correspondant, il entrera le code de gestion des exceptions. Une fois le traitement terminé, cela signifie que toute l'instruction TRY-PATCH se termine. D'autres clauses de capture n'ont plus la possibilité de faire correspondre et de capturer des types d'exceptions.
Java décrit les types d'exceptions via des classes d'exception, et la hiérarchie des classes d'exception est illustrée à la figure 1. Pour les programmes d'exception avec plusieurs clauses de capture, vous devriez essayer de mettre la clause Catch qui capte d'abord la classe d'exception sous-jacente et d'essayer de mettre la clause de capture qui attrape la classe d'exception de niveau relativement élevé plus tard. Sinon, la clause Catch qui attrape la classe d'exception sous-jacente sera probablement bloquée.
La classe d'exception RuntimeException comprend diverses exceptions courantes lors de l'exécution, et la classe ArithMeticexception et la classe ArrayIndexoutofBoundSexception sont toutes deux sous-classes. Par conséquent, la clause Catch de la classe d'exception RuntimeException doit être placée à la fin, sinon elle peut bloquer la gestion ultérieure des exceptions ou provoquer une erreur de compilation.
2. Énoncé d'essai et finalement
L'instruction TRY-Catch peut également inclure la troisième partie, qui est la clause enfin. Il indique ce qui doit être exécuté, que ce soit une exception ou non. La forme de syntaxe générale de l'instruction TRY-PATCH-FINALABLE est:
Try {// Code de programme qui peut se produire Exception} catch (Type1 id1) {// Catch et traite le type d'exception lancé par Try Type1} Catch (Type2 ID2) {// Catch and Treat le type d'exception lancé par Try Type2} Enfin {// Bloc des instructions qui sera exécutée, si une exception se produit}Exemple 6 Manager des exceptions avec clause enfin.
classe publique TestException {public static void main (String args []) {int i = 0; Salutations à cordes [] = {"Hello World!", "Hello World !!", "Hello World !!!" }; while (i <4) {try {// Portez une attention particulière à la conception de la variable de contrôle de boucle i pour éviter de provoquer des boucles infinies System.out.println (salutations [i ++]); } catch (arrayIndexoutofBoundSexception e) {System.out.println ("ArraySubScript Out-of-Bounds Exception"); } enfin {System.out.println ("--------------------------"); }}}}Résultats en cours:
Bonjour le monde!
--------------------------------
Bonjour le monde !!
--------------------------------
BONJOUR LE MONDE!!!
--------------------------------
Exception de l'indice de bornes du tableau
--------------------------------
Dans l'exemple 6, veuillez prêter une attention particulière à la conception du bloc de déclaration dans la clause d'essai. Si la conception est la suivante, une boucle morte se produira. Si conçu comme:
essayez {System.out.println (salutations [i]); i ++; }résumé:
Essayez le bloc: utilisé pour assister aux exceptions. Par la suite, zéro ou plus de blocs de capture peuvent être connectés. S'il n'y a pas de bloc de capture, il doit être suivi d'un bloc enfin.
Catch Block: Utilisé pour gérer les exceptions prises par essai.
Enfin Bloc: les instructions du bloc final seront exécutées, que l'exception soit capturée ou traitée. Lorsqu'une instruction de retour est rencontrée dans un bloc d'essai ou un bloc de capture, le bloc énoncé enfin sera
S'exécute avant le retour de la méthode. Dans les 4 cas spéciaux suivants, le bloc final ne sera pas exécuté:
1) Une exception s'est produite dans le bloc finalement de l'instruction.
2) Utilisez System.exit () dans le code précédent pour quitter le programme.
3) Le fil où le programme est situé meurt.
4) Éteignez le processeur.
3.
1) Une prise ou un blocage enfin doit être ajouté après l'essai. Après le bloc d'essai, les blocs de capture et enfin peuvent être connectés en même temps, mais il y a au moins un bloc.
2) L'ordre de bloc doit être suivi: si le code utilise à la fois les cordons et enfin les blocs, le bloc de capture doit être placé après le bloc d'essai.
3) Le bloc de capture est lié au type de la classe d'exception correspondante.
4) Un bloc d'essai peut avoir plusieurs blocs de capture. Si c'est le cas, le premier bloc correspondant est exécuté. C'est-à-dire que la machine virtuelle Java correspond aux objets d'exception lancés réels avec les types d'exceptions déclarés par chaque bloc de code de capture en séquence. Si l'objet d'exception est un type d'exception ou une instance de sa sous-classe, le bloc de code de capture sera exécuté et aucun autre bloc de code de capture ne sera exécuté.
5) Structure d'essai imbriquée finalement.
6) Dans la structure TRY-Catch-finalement, une exception peut être remontée.
7) En plus des situations suivantes, l'exécution de finalement se termine: le JVM se termine prématurément (appelé System.exit (int)); lance une exception non perdue dans le bloc enfin; L'ordinateur est éteint, tiré ou attaqué par un virus.
4. L'ordre d'exécution des blocs d'essai, de capture et enfin de l'instruction:
1) Lorsque l'essai n'attrape pas une exception: les instructions du bloc de l'instruction TRY sont exécutées une par une, et le programme sautera le bloc de l'instruction Catch et exécutera le bloc de l'instruction finalement et les instructions suivantes;
2) Lorsque l'essai attrape une exception, le bloc de l'instruction Catch ne gère pas cette exception: lorsqu'une exception se produit dans une instruction dans le bloc de déclaration d'essai et le bloc d'instruction Catch qui ne gère pas cette exception, l'exception sera jetée à la JVM pour le traitement, et l'instruction dans le bloc de l'instruction enfin sera toujours exécutée, mais l'instruction après le bloc de relevé final ne sera pas exécutée;
3) Lorsqu'un essai attrape une exception, le bloc de l'instruction Catch gère cette exception: il est exécuté dans le bloc d'essai dans l'ordre. Lorsqu'une exception se produit lorsqu'une exception se produit dans une certaine déclaration, le programme sautera au bloc de l'instruction Catch et correspondra à un par un. Trouvez le gestionnaire correspondant. D'autres blocs d'instructions de capture ne seront pas exécutés. Dans le bloc d'essai, l'instruction après une exception ne sera pas exécutée. Une fois le bloc d'instruction Catch Exécuté, l'instruction dans le bloc de l'instruction final sera exécutée, et enfin l'instruction après l'exécution du bloc de l'instruction finale;
Illustration de l'exécution des blocs Try, Catch et enfin des instructions:
La figure 2 illustre l'exécution des blocs d'essai, de capture et enfin
3.2 Jetez une exception
Tout code Java peut lancer des exceptions, telles que: code écrit par vous-même, code du package de l'environnement de développement Java ou système d'exécution Java. Peu importe de qui il s'agit, vous pouvez lancer une exception à travers la déclaration Java Throw. Toute exception projetée à partir de la méthode doit être utilisée avec la clause des lancers.
1. lance l'exception de lancer
Si une méthode peut avoir une exception mais n'a pas la possibilité de gérer une telle exception, vous pouvez utiliser la clause des lancers pour déclarer l'exception jetée à la déclaration de la méthode. Par exemple, une voiture peut échouer lors de la course et la voiture elle-même ne peut pas gérer cette panne, alors laissez le conducteur y faire face.
L'instruction LORDS est utilisée pour déclarer le type d'exception à lancer lorsque la méthode est définie. Si le type d'exception d'exception est lancé, la méthode est déclarée lancer toutes les exceptions. Plusieurs exceptions peuvent être divisées à l'aide de virgules. Le format de syntaxe de l'instruction des lancers est:
MethodName lance l'exception1, exception2, .., exceptionn {} lance après le nom de la méthode exception1, exception2, ..., exceptionn est la liste des exceptions à lancer. Lorsqu'une méthode lance une liste d'exceptions d'exceptions, la méthode ne gérera pas les exceptions de ces types et de leurs types de sous-classe, mais sera jetée à la méthode qui appelle la méthode et sera gérée par elle. Par exemple:
Importer java.lang.Exception; classe publique TestException {static void POP () lève NegatiVeArraySizeException {// Définir la méthode et lancer l'exception NegativeArraySizeException int [] arr = new int [-3]; // Créer un tableau} public static void main (String [] args) {// méthode principale try {// tessge instruction gère les informations d'exception pop (); // Appelez la méthode pop ()} catch (negatiVeArraySizeException e) {System.out.println ("Exception lancée par la méthode pop ()"); // Informations d'exception de sortie}}}Après avoir lancé l'exception à l'appelant à l'aide du mot-clé lancers, si l'appelant ne veut pas gérer l'exception, vous pouvez continuer à le lancer, mais en fin de compte, il doit y avoir un appelant qui peut gérer l'exception.
La méthode POP ne gère pas l'exception NegatiVEArraySizeException, mais est gérée par la fonction principale.
La règle des lancers lance des exceptions:
1) S'il s'agit d'une exception non contrôlée, c'est-à-dire une erreur, RuntimeException ou leurs sous-classes, vous pouvez déclarer l'exception à lancer sans utiliser le mot-clé lancers, et la compilation passera en douceur, mais elle sera lancée par le système à l'exécution.
2) Toutes les exceptions vérifiées qui peuvent être lancées par la méthode doivent être déclarées. Autrement dit, si une méthode peut avoir une exception enregistrable, elle sera soit prise avec une instruction TRY-PATCH ou la lancera avec une déclaration de clause de lancers, sinon elle entraînera une erreur de compilation.
3) Seulement lorsqu'une exception est lancée, l'appelant de la méthode doit gérer ou remédier à l'exception. Lorsque l'appelant de méthode n'est pas en mesure de gérer l'exception, il devrait continuer à le lancer au lieu de l'avaler entier.
4) La méthode d'appel doit suivre toutes les règles de gestion et de déclaration d'exception vérifiables. Si une méthode est écrasée, les exceptions différentes de la méthode écrasée ne peuvent pas être déclarées. Toute exception déclarée doit être une sous-classe similaire ou une sous-classe de l'exception déclarée par la méthode remplacée.
Par exemple:
void Method1 () lève ioException {} // Erreur de compilation légale //, ioException doit être capturé ou déclaré pour lancer vide method2 () {méthody1 (); } // Legal, déclare à lancer ioException void method3 () lève ioException {méthode1 (); } // Legal, Declare to Throw Exception, ioException est une sous-classe de l'exception void method4 () lève une exception {méthode1 (); } // Legal, capture ioException void method5 () {try {méthode1 (); } catch (ioException e) {…}} // Erreur de compilation, vous devez attraper ou déclarer l'exception lancée vide méthode6 () {try {méthode1 (); } catch (ioException e) {Throw New Exception ();}} // Legal, Declare Throw Exception void Method7 () lève une exception {try {Method1 (); } catch (ioException e) {lancer une nouvelle exception ();}} La base pour déterminer qu'une exception peut se produire dans une méthode est la suivante:
1) Il y a une déclaration de lancer dans la méthode. Par exemple, le bloc de code Catch de la méthode de méthode 7 () ci-dessus a une instruction THOR.
2) D'autres méthodes sont appelées et d'autres méthodes utilisent la clause de lancement pour déclarer une exception à lancer. Par exemple, la méthode Method3 () appelle la méthode Method1 (), et la méthode Method1 () déclare qu'une ioException est lancée, donc une ioException peut se produire dans la méthode Method3 ().
2. Utilisez le lancer pour lancer une exception
Le lancer apparaît toujours dans le corps de la fonction et est utilisé pour lancer une exception de type jetable. Le programme se terminera immédiatement après l'instruction Throw, l'instruction après qu'il ne peut pas être exécuté, puis dans tous les blocs d'essai qui le contiennent (peut-être dans la fonction d'appel de niveau supérieur) recherchent des blocs d'essai contenant la clause Catch qui la correspond à l'intérieur.
Nous savons que les exceptions sont des objets d'instance de classe d'exception, et nous pouvons créer des objets d'instance de classe d'exception à lancer dans l'instruction Throw. Le format de syntaxe de cette déclaration est:
Jetez un nouveau nom d'exception;
Par exemple, lancez un objet d'exception de la classe IOException:
Jetez une nouvelle ioException;
Il convient de noter que je lance uniquement des objets d'instance qui peuvent lancer des classes jetables ou sous-classes. L'opération suivante est incorrecte:
lancer une nouvelle chaîne ("exception");En effet, String n'est pas une sous-classe de la classe jetable.
Si une exception de vérification est lancée, vous devez également déclarer le type d'exception que la méthode peut jeter l'en-tête de la méthode. L'appelant de cette méthode doit également vérifier la gestion de l'exception lancée.
Si toutes les méthodes lancent la couche d'exception acquise par calque, le JVM finira par le traiter, et le traitement est également très simple, qui consiste à imprimer le message d'exception et les informations de pile. Si une erreur ou RuntimeException est lancée, l'appelant de la méthode a la possibilité de gérer l'exception.
test de package; Importer java.lang.Exception; classe publique TestException {static int quotient (int x, int y) lève MyException {// Définir la méthode pour lancer une exception si (y <0) {// déterminer si le paramètre est inférieur à 0 lancement de MyException ("le diviseur ne peut pas être un nombre négatif"); // Informations d'exception} Retour x / y; // Valeur de retour} public static void main (String args []) {// méthode principale int a = 3; int b = 0; Try {// L'instruction TRY contient des instructions qui peuvent avoir des exceptions int résultat = quotient (a, b); // Méthode d'appel Quoteent ()} catch (myException e) {// Gire le système d'exception personnalisé.out.println (e.getMessage ()); // Informations d'exception de sortie} catch (arithmeticexception e) {// Gire arithmeticexception exception system.out.println ("divorceipt ne peut pas être 0"); // Informations d'invite de sortie} catch (exception e) {// gérer d'autres exceptions System.out.println ("Autres exceptions se sont produites dans le programme"); // Informations d'invite de sortie}}} classe MyException étend l'exception {// Créer un message de chaîne de classe d'exception personnalisée; // Définir la variable de type String public MyException (String errorMessagr) {// Method Method Method = ErrorMessagr; } public String getMessage () {// Override getMessage () Méthode RETOUR Message; }}3.3 Chaîne d'exception
1) Si le quotient (3, -1) est appelé, une exception MyException se produira et que le programme sera transféré au bloc de code CATCH (MyException E) à exécuter;
2) Si le quotient (5,0) est appelé, une exception Arithmeticexception sera soulevée en raison de l'erreur "Divider is 0". Il appartient à la classe d'exception d'exécution et est automatiquement lancé par le système d'exécution Java. La méthode quotient () n'attrape pas l'exception ArithMeticexception. Le système Java Runtime recherchera la méthode principale le long de la pile d'appels de méthode et téléchargera l'exception lancée sur l'appelant de la méthode quotient ():
Int result = quotient (a, b); // appelle la méthode quotient ()
Étant donné que cette déclaration est dans la zone de surveillance d'essayer, la conception Arithmeticexception avec "Divider est 0" remise en arrière est rejetée par le système d'exécution Java et correspond à la clause Catch:
Catch (arithMeticexception e) {// Gire ArithMeticexception Exception System.out.println ("Le diviseur ne peut pas être 0"); // Informations d'invite de sortie}Le résultat du traitement est que le diviseur de sortie ne peut pas être 0 ". Java, un mécanisme de traitement qui transmet les informations d'exception vers le haut, forme une chaîne d'exception.
L'exception véritable lancée par la méthode Java sera transmise à la méthode d'appel avec la capacité de traitement en fonction de la pile d'appels et le long de la hiérarchie de l'appel de la méthode, et le niveau le plus élevé sera jusqu'à la méthode principale. Si l'exception est transmise à la méthode principale, mais que le principal n'a pas la possibilité de le gérer et ne lance pas l'exception par la déclaration des lancers, une erreur de compilation peut se produire.
3) Si d'autres exceptions se produisent, la capture (exception E) sera utilisée pour attraper. Since Exception is the parent class of all exception classes, if the catch (Exception e) code block is placed in front of the other two code blocks, the subsequent code blocks will never be executed, which makes no sense, so the order of catch statements cannot be replaced.
3.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果cause 不存在或未知，则返回null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
3. Autres
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.