1. Résumé de l'exception Java:
L'exception signifie un fonctionnement anormal lorsque le programme est en cours d'exécution
1. Origine de l'exception:
La description des problèmes dans les choses réelles à travers la forme des classes Java et scellée dans un objet
En fait, c'est la manifestation de l'objet après que Java a décrit des situations anormales.
2. Il y a deux types de problèmes: l'un est un problème grave, et l'autre est un problème grave
Pour les cas graves, Java le décrit via la classe d'erreur
L'erreur n'est généralement pas écrite pour le traiter.
Pour non série, Java est décrit par la classe d'exception
Pour exception, vous pouvez utiliser des méthodes de traitement ciblées pour le gérer
3. Les exceptions courantes comprennent: les exceptions transfrontalières transfrontalières du marqueur d'angle de tableau, les exceptions du pointeur nul ...
4. Que l'erreur ou l'exception ait un contenu commun.
Par exemple: des nouvelles anormales, des causes, etc.
Classe lancable // premium (les deux classes suivantes sont extraites du même point commun)
| --Error
| --Excption // deux sous-classes (il y a de nombreux problèmes définis (l'exception se produit)) / * Le nom de classe parent est le nom du suffixe de la sous-classe * /
Exemple 1: Exemple d'occurrence d'exception
classe Demo {public int div (int x, int y) {return x / y; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); int x = d.div (4,0); // 0 en tant que diviseur System.out.println ("x =" + x); System.out.println ("Over"); }}Résultats en cours:
Exception dans Thread "Main" java.lang.arithmeticexception: / par zéro
à Demo.Div (exceptiondemo.java:5)
sur exceptiondemo.main (exceptiondemo.java:15)
D'après les résultats ci-dessus, nous pouvons analyser qu'une exception s'est produite dans les deux lignes 5 et 15. En effet, le mécanisme de division, le diviseur ne peut pas être 0, et une exception sera lancée lorsque l'opération sera exécutée.
Exemple 2: Exception Exemple 2, débordement de mémoire
classe Demo {public int div (int x, int y) {return x / y; }} classe exceptiondemo {public static void main (String args []) {/ * Demo d = new Demo (); int x = d.div (4,0); System.out.println ("x =" + x); System.out.println ("Over"); * / octet [] arr = nouveau octet [1024 * 1024 * 1000]; }}Résultats en cours:
Exception dans Thread "Main" Java.lang.outofMemoryError: Java tas Space
sur exceptiondemo.main (exceptiondemo.java:19)
java.lang.outofMemoryError: représente l'exception de débordement de mémoire
2. Manipulation des exceptions:
Pour la gestion des exceptions, Java fournit des déclarations uniques pour le traitement
Format
essayer
{
code qui doit être détecté;
}
attraper
{
Code pour gérer les exceptions; (Méthode de traitement)
}
Enfin
{
Code qui sera définitivement exécuté; (Méthode de traitement)
}
Exemple 1: Démontrer la déclaration d'essai
classe Demo {public int div (int x, int y) {return x / y; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); essayez {int x = d.div (4,0); System.out.println ("x =" + x); } catch (exception e) {System.out.println ("Divinefreved Divisor"); } System.out.println ("Over"); / * octet [] arr = nouveau octet [1024 * 1024 * 1000]; * /}}Résultats en cours:
Il y a une erreur dans le diviseur
sur
Analyse des résultats: lorsque le programme est en cours d'exécution, lorsque l'instruction de division est exécutée: Retour x / y, un objet d'exception est généré. New Archmeticexception (), l'instruction TRYAGNE capture cet objet avec les paramètres de l'instruction Catch.
Exception e = new ArchMeticexception ();
Après avoir exécuté l'instruction Catch Processing, le problème est traité, l'instruction finale est terminée et la sortie est terminée
Exemple 2: Effectuez des opérations de méthode commune sur les objets d'exception capturés (la méthode de la classe parent jetable)
String getMessage (); // obtenir des informations d'exception
toString () // Nom de l'exception de retour: Informations d'exception
PrintstackTrace () // Nom d'exception de sortie, informations d'exception, emplacement de l'exception de l'occurrence
classe Demo {public int div (int x, int y) {return x / y; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); essayez {int x = d.div (4,0); System.out.println ("x =" + x); } catch (exception e) {System.out.println ("Divinefreved Divisor"); // Obtenir des informations d'exception System.out.println (e.getMessage ()); // obtenir des informations d'exception, le nom d'exception System.out.println (e.toString ()); // Nom d'exception de sortie, informations d'exception, emplacement où l'exception se produit e.printStackTrace (); } System.out.println ("Over"); / * octet [] arr = nouveau octet [1024 * 1024 * 1000]; * /}}Résultats en cours:
Il y a une erreur dans le diviseur
/ par zéro
java.lang.arithmeticexception: / par zéro
java.lang.arithmeticexception: / par zéro
à Demo.Div (exceptiondemo.java:5)
sur exceptiondemo.main (exceptiondemo.java:17)
sur
D'après l'analyse des résultats en cours d'exécution, le mécanisme de gestion des exceptions par défaut de JVM appelle réellement la méthode PrintstackTrace.
Exemple 3: Deux façons de gérer le lancer d'exception
1. Jetez-le à la machine virtuelle JVM pour le traitement
2. Gérez les exceptions jetées vous-même
Class Demo {public int div (int x, int y) lève exception / * exception lance lorsque des exceptions peuvent se produire * / {return x / y; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); int x = d.div (4,0); System.out.println ("x =" + x); System.out.println ("Over"); }}Résultats en cours:
Exceptiondemo.java:15: erreur: exception d'exception non déclaré exception; il doit être capturé ou déclaré pour lancer
int x = d.div (4,0);
^
1 erreur
Analyse des résultats: c'est parce qu'aucune exception n'est traitée
Méthode de traitement 1: lancer en continu des exceptions et laisser la machine virtuelle JVM le gérer lui-même
Class Demo {public int div (int x, int y) lève exception / * exception lance lorsque des exceptions peuvent se produire * / {return x / y; }} classe exceptiondemo {public static void main (String args []) lève des exceptions / * continuer à lancer des exceptions et donner à la machine virtuelle * / {Demo d = new Demo (); int x = d.div (4,0); System.out.println ("x =" + x); System.out.println ("Over"); }}Méthode de manutention 2: gérer les exceptions par vous-même
Class Demo {public int div (int x, int y) lève exception / * exception lance lorsque des exceptions peuvent se produire * / {return x / y; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); essayez // gérer l'exception vous-même {int x = d.div (4,0); System.out.println ("x =" + x); } catch (exception e) {System.out.println ("Divinefreved Divisor"); // obtenir des informations d'exception, le nom d'exception System.out.println (e.toString ()); System.out.println ("Over"); }}}Résumer:
Déclarer des exceptions sur les fonctions. Il est pratique d'améliorer la sécurité, permettant à la source d'appel d'être traitée sans traitement des défaillances de compilation.
Exemple 4: Gestion de plusieurs exceptions
1. Lors de la déclaration des exceptions, il est recommandé de déclarer des exceptions plus spécifiques, afin qu'ils puissent être gérés plus spécifiquement.
2. Déclarez plusieurs exceptions, et il y a plusieurs blocs de capture. Ne définissez pas rapidement la capture inutile.
S'il existe des relations d'héritage dans plusieurs blocs de capture, le bloc de capture d'exception de classe parent est placé ci-dessous.
Class Demo {public int div (int x, int y) lève ArithMeticexception, arrayIndexoutofboundSexception {int arr [] = new int [x]; System.out.println (arr [4]); retour x / y; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); essayez {int x = d.div (4,0); System.out.println ("x =" + x); } catch (arithmeticexception e) / * diviser l'objet d'exception est reçu, la première exécution est * / {System.out.println ("Divinefured Divisor"); // obtenir des informations d'exception, le nom d'exception System.out.println (e.toString ()); System.out.println ("Over"); } catch (arrayIndexoutofBoundSexception e) / * Recevez l'objet avec les données hors limites, la deuxième exécution est * / {System.out.println ("arrayout"); // Sortie d'informations d'exception System.out.println (e.toString ()); } catch (exception e) / * Recevez l'exception de la classe parent et exécutez-la à la fin. Il est recommandé de ne pas écrire ceci, que le programme se termine * / / * utiliser le polymorphisme * / {System.out.println (e.toString ()); }}}Résultats en cours:
Le tableau est hors limites
java.lang.arrayindexoutofboundSexception: 4
suggestion:
Lors du traitement des captures, vous devez définir des méthodes de traitement spécifiques dans les captures.
Ne définissez pas simplement e.printStackTrace ().
Ne vous contentez pas d'écrire une instruction de sortie
Parce que les utilisateurs ne peuvent pas le comprendre, il est préférable de l'enregistrer dans un fichier et de l'envoyer à nos développeurs pour le visualiser régulièrement.
Exemple 5: Exception personnalisée
Avez-vous remarqué que les exceptions que nous utilisons sont toutes encapsulées dans Java
Cependant, dans le développement réel, les exceptions qui apparaissent dans notre programme peuvent être que Java n'est pas encapsulée.
Pour le moment, vous devez le définir vous-même
Selon le code ci-dessus, je définis que le diviseur ne peut pas être un nombre négatif. Le code est le suivant
Class Demo {public int div (int x, int y) lève fushuexception / * en tête d'une exception * / {if (y <0) {throw new fushuexception ("le dénominateur a un nombre négatif ------ / bu fushu", y); / * L'objet qui lance l'exception manuellement * /} return x / y; }} classe Fushuexception étend une exception {private int value; Fushuexception (String m, int value) {super (m); / * Passez des paramètres à la méthode GetMessage de l'exception de la classe parent * / this.value = valeur; } public int getValue () / * Méthode personnalisée, Retour Nombre négatif * / {RETOUR-valeur; }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); essayez {int x = d.div (4, -3); System.out.println ("x =" + x); } catch (fushuexception e) / * catch exception objet * / {System.out.println (e.getMessage () + e.getValue ()); } System.out.println ("Over"); }}Résultats en cours:
Un nombre négatif apparaît dans le dénominateur ----- / bu fushu-3
sur
D'après les résultats ci-dessus, nous pouvons voir
Dans ce programme, le diviseur est -3, qui est également considéré comme mauvais et ne peut pas être effectué.
Ensuite, vous devez avoir une description personnalisée de ce problème.
Lorsque vous lancez un objet d'exception à l'intérieur de la fonction apparaît, l'action de traitement correspondante doit être donnée.
Ou géré en interne.
Soit déclarer la fonction pour que l'appelant le gére.
De manière générale, les exceptions apparaissent dans la fonction et doivent être déclarées sur la fonction.
Il a été constaté qu'il n'y avait que le nom d'exception dans le résultat imprimé, mais il n'y avait aucune information d'exception.
Car l'exception personnalisée ne définit pas les informations.
Comment définir des informations d'exception?
Parce que le fonctionnement des informations d'exception a été achevé dans la classe parent.
Par conséquent, la sous-classe n'a besoin que de transmettre les informations d'exception à la classe parent lors de la construction via la super instruction.
Ensuite, vous pouvez obtenir directement des informations d'exception personnalisées via la méthode GetMessage.
Les exceptions personnalisées doivent être une exception d'héritage de classe personnalisée.
Raison de l'exception de l'héritage:
Un système d'exception a une fonctionnalité: car les classes d'exception et les objets d'exception sont lancées.
Ils sont tous jetables. Cette jetabilité est une caractéristique unique du système jetable.
Seules les classes et objets de ce système peuvent être exploités par des lancers et des lancers.
La différence entre les lancers et le lancer
Les lancers sont utilisés sur les fonctions.
Le lancer est utilisé dans la fonction.
La classe d'exception suivie de lancers. Peut être suivi de plusieurs. Séparés par des virgules.
Le lancer est suivi par l'objet d'exception.
Exemple 6: Il existe une exception de sous-classe spéciale dans l'exception RuntimeException
Si l'exception est lancée dans le contenu de la fonction, la fonction peut être déclarée sans déclaration et la compilation sera transmise.
Si l'exception est déclarée sur la fonction, l'appelant ne peut pas le traiter et la compilation sera effectuée via
La raison pour laquelle il n'est pas nécessaire de déclarer la fonction est que l'appelant n'a pas besoin de le gérer.
Lorsque cette exception se produit, j'espère que le programme s'arrêtera, car il ne peut pas fonctionner pendant l'exécution. J'espère que le programme s'arrêtera après l'arrêt du programme.
Le programmeur a modifié le code.
Class Demo {public int div (int x, int y) lève fushuexception / * Le résultat du lancer ou de ne pas lancer est le même * / {if (y <0) {throw new fushuexception ("le dénominateur a un nombre négatif ----- / bu fushu", y); } return x / y; }} classe Fushuexception étend RuntimeException / * héritage RuntimeException * / {fushuexception (String m, int value) {super (m); }} classe exceptiondemo {public static void main (String args []) {Demo d = new Demo (); int x = d.div (4, -3); / * L'exception apparaîtra après l'exécution de cela, il n'y aura aucun problème avec la compilation * / System.out.println ("x =" + x); System.out.println ("Over"); }}Résultats en cours:
Exception dans Thread "Main" Fushuexception: un nombre négatif apparaît dans le dénominateur ------ / bu fushu
à Demo.Div (exceptiondemo.java:7)
sur exceptiondemo.main (exceptiondemo.java:26)
D'après les résultats ci-dessus, nous pouvons voir:
Lorsque l'exception personnalisée: si l'exception se produit, l'opération ne peut pas être continue.
Laissez l'exception personnalisée hériter de RuntimeException.
Pour des exceptions, il existe deux types:
1. Exception détectée pendant la compilation.
2. Exception qui n'est pas détectée pendant la compilation (exception d'exécution. RuntimeException et ses sous-classes)
L'article ci-dessus comprend de manière approfondie le mécanisme de gestion des exceptions en Java est tout le contenu que j'ai partagé avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.