Le phénomène anormal des programmes Java en cours d'exécution s'appelle les erreurs de course. Selon leur nature, il peut être divisé en deux catégories: erreur (erreur) et exception (exception); Ils ont une classe de parent commune (également la classe parent de haut niveau de toutes les exceptions): Thrownable.
Structure des classes d'exception
Erreur
L'erreur est générée par le JVM et abandonnée sans traitement; Ces erreurs ne sont généralement pas liées au code et aux opérations exécutées, et sont des problèmes relativement graves dans la machine virtuelle et ne peuvent pas être résolus par le programme lui-même (les erreurs courantes incluent des boucles mortes, des fuites de mémoire, etc.).
Une erreur commune est une erreur de machine virtuelle Java (VirtualMachineerror). Lorsque le JVM n'a plus les ressources de mémoire requises pour poursuivre l'opération, une OverofMemoryError apparaîtra. Lorsque ces exceptions se produisent, la machine virtuelle Java (JVM) choisit généralement de terminer les threads.
Exception
L'exception est utilisée comme objet et est rejetée ou traitée par les programmes Java; Habituellement, les causes des exceptions sont les suivantes: le code ou le code d'appel est incorrect, les ressources du système d'exploitation ne sont pas disponibles et la bibliothèque d'exécution du langage commun rencontre un accident;
Les exceptions sont divisées en exceptions d'exécution générées par les machines virtuelles (RuntimeException, telles que les pointeurs nuls, les bornes à des limites) et les exceptions non runtimes causées par des accidents de programme (tels que iOException);
Exception d'exécution: le programme peut choisir de capturer et de le traiter ou de le lancer directement sans traitement; Les exceptions courantes d'exécution incluent le débordement d'algorithme (dépassant la plage d'expression numérique), le diviseur est zéro, débordement de mémoire, pointeur nul, paramètres non valides, etc. Ces exceptions sont des erreurs de programmation dans le programme lui-même. Vous pouvez ajuster la direction en cours d'exécution du code d'exception pour maintenir le programme en cours d'exécution jusqu'à ce qu'il se termine normalement;
Exception non-runtime: les exceptions inattendues du type de runtimeException sont appelées exceptions non-runtime. Du point de vue de la syntaxe du programme, ce sont des exceptions qui doivent être traitées. S'ils ne sont pas traités, le programme ne peut pas être compilé et réussi; Les exceptions courantes non entimes incluent IOException, telles que: les fichiers de ressources ne peuvent pas être trouvés, etc., ce qui signifie que le programme ne peut pas exécuter avec succès lors de la rencontre d'une situation inattendue.
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.
Exceptions vérifiables et exceptions non enregistrables
Les exceptions Java (ErrorAndexceptions) peuvent être divisées en deux autres catégories en fonction de la compilation et de la réalisation du programme: Exceptions vérifiées et exceptions non contrôlées.
Peut vérifier les exceptions
L'exception peut être vérifiée: correspondant à des exceptions non-runtime, le compilateur peut vérifier les erreurs attendues lors de la compilation du programme. Cette exception doit être manipulée. Il existe deux façons de le faire face: l'instruction TRY-PATCH capte l'exception ou la clause des lancers déclare lancer une exception, et le type d'exception est déclaré en dehors de l'en-tête de la méthode (en utilisant l'exception des lancers) et l'appelant peut choisir de gérer l'exception reçue.
En parlant de ces deux façons de gérer, nous devons parler des 5 mots clés de la manipulation de l'exception Java: essayez, attrapez, enfin, jette, jetez
1. Utilisez l'instruction TRY-PATCH pour traiter la capture (l'en-tête de la méthode n'a pas besoin d'être déclaré)
Les trois blocs de déclaration d'essayer, de capture et de finalement ne peuvent pas apparaître seuls. Les trois peuvent être combinés en couple d'essai / essai-catch-finalement / essai finalement.
Il peut y avoir plusieurs blocs de capture, et à ce moment, l'un des codes de blocs de capture ne peut être égalé que de haut en bas;
Enfin, au maximum, une variable n'est pas accessible les unes aux autres dans les trois blocs d'instructions.
Dans cette section, la combinaison de coups d'essai est utilisée pour gérer l'exception véritable, en jetant l'exception vers le haut, exemple:
public xmlReaderHdu (String xmlfile) {super (); this.xmlfile = xmlfile; this.filename = staticconfig.umlpathprefixhdu; try {saxReader reader = new saxReader (); document dom = reader.read (xmlfile); root = dom.getrootement ();} catch (exception e1) {handle1…} catch (exception e2) {handle1…}}2.
Tout d'abord, utilisez le jet à l'intérieur du corps de la méthode pour lancer une exception;
Ensuite, la méthode est déclarée à l'extérieur de la tête et lance l'exception jetée à l'intérieur à l'aide de lancers;
Exemple 1: Try-Patch lance une exception
public xmlReaderHdu (String xmlfile) lève l'exception {super (); this.xmlfile = xmlfile; this.filename = staticconfig.umlpathprefixhdu; try {saxreader reader = new saxReader (); document dom = reader.read (xmlfile); root = dom.getrootement ();} catch (exception e1) {lance une nouvelle exception (e1);}}Exemple 2: exception personnalisée à lancers
Liste privée <Usecase> ReadUcInformation () lève une exception {if (e1.hascontent ()) {if (e1.element ("name"). getText (). Equals ("prédidition")) {uc.setprecondition (e1.elementText ("contenu"));} nom else {lancer une nouvelle exception ("usecase contrainte erreur");}}}Impossible de vérifier les exceptions
Exceptions incontrôlables: inclut l'erreur d'erreur et l'exception d'exécution RuntimeException
Les exceptions d'exécution peuvent être transmises lors de la compilation du programme. Il ne peut pas être détecté via une syntaxe statique quelles fonctions peuvent lancer des exceptions. Ce n'est que lorsque l'exception est trouvée (c'est-à-dire en fonction de l'état d'exécution, elle est déterminée par l'état d'exécution);
Vous pouvez choisir de capturer le traitement ou l'affichage lancé (MustBecaughtorDeclearEdTobethRown). 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.
Résumer
Ce qui précède concerne l'analyse de la connaissance de base des exceptions Java dans cet article, j'espère qu'elle sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!