Qu’est-ce que l’exception Java ? Comment les exceptions Java sont-elles gérées ?

Le contenu de cet article est de vous présenter qu'est-ce que l'exception Java ? Comment les exceptions Java sont-elles gérées ? Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

1. Exceptions JAVA

Les exceptions font référence à diverses situations inattendues, telles que : fichier introuvable, échec de 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 normal des instructions. Java décrit diverses exceptions via de nombreuses sous-classes de la classe Throwable dans l'API. Par conséquent, les exceptions Java sont des objets, des instances d'une sous-classe Throwable, qui décrivent les conditions d'erreur qui se produisent dans un élément de codage. L'erreur lèvera une exception lorsque la condition est générée.

Diagramme hiérarchique des classes d'exceptions Java :

Throwable : Il y en a deux Deux sous-classes importantes : Exception et Error, toutes deux sont des sous-classes importantes de la gestion des exceptions Java et chacune contient un grand nombre de sous-classes.

Erreur : est une erreur que le programme ne peut pas gérer, indiquant un problème grave lors de l'exécution de l'application. La plupart des erreurs n'ont rien à voir avec les actions effectuées par le rédacteur du code et représentent plutôt des problèmes avec la JVM (Java Virtual Machine) pendant l'exécution du code. Par exemple, erreur d'exécution de la machine virtuelle Java (Virtual MachineError), lorsque la JVM ne dispose plus des ressources mémoire nécessaires pour continuer à exécuter l'opération, une OutOfMemoryError se produira. Lorsque ces exceptions se produisent, la machine virtuelle Java (JVM) choisit généralement de mettre fin au thread.

Exception : est une exception qui peut être gérée par le programme lui-même.

Les exceptions Java (y compris les exceptions et les erreurs) sont divisées en exceptions vérifiées (exceptions vérifiées) et exceptions non vérifiées (exceptions non vérifiées) .

Exceptions vérifiables (exceptions que le compilateur exige pour être gérées) : exceptions faciles à produire et tolérables lorsqu'un programme correct est en cours d'exécution. Bien que les exceptions vérifiables soient des situations anormales, leur apparition peut être attendue dans une certaine mesure, et une fois que de telles situations anormales se produisent, elles doivent être traitées d'une manière ou d'une autre.

À l'exception de RuntimeException et de ses sous-classes, toutes les autres classes Exception et leurs sous-classes sont des exceptions vérifiables. La caractéristique de ce type d'exception est que le compilateur Java la vérifiera, c'est-à-dire que lorsque ce type d'exception peut se produire dans le programme, soit utilisez l'instruction try-catch pour l'attraper, soit utilisez les lancers. clause pour le déclarer, sinon le compilateur ne passera pas.

Exceptions non vérifiables (exceptions que le compilateur ne nécessite pas de gestion forcée) : incluent les exceptions d'exécution (RuntimeException et ses sous-classes) et les erreurs (Error).

Remarque : Les exceptions peuvent être gérées par le programme lui-même, mais les erreurs ne peuvent pas être gérées.

Exception Cette exception est divisée en deux grandes catégories : les exceptions d'exécution et les exceptions non-exécutables (exceptions de compilation). Le programme doit gérer ces exceptions autant que possible.

Exceptions d'exécution : sont des exceptions de la classe RuntimeException et de ses sous-classes, telles que NullPointerException (exception de pointeur nul), IndexOutOfBoundsException (indice Out -of-bounds exceptions), etc. Ces exceptions sont des exceptions non contrôlées. Vous pouvez choisir de les capturer dans le programme ou de ne pas les gérer. Ces exceptions sont généralement causées par des erreurs logiques du programme, et le programme doit essayer d'éviter l'apparition de telles exceptions d'un point de vue logique.

La caractéristique des exceptions d'exécution est que le compilateur Java ne les vérifie pas, c'est-à-dire que lorsque ce type d'exception peut survenir dans le programme, même si elle n'est pas capturée avec une instruction try-catch, il n'est pas déclaré avec une clause throws. Lancez-le et il sera compilé.

Exception non-exécutable (exception de compilation) : est une exception autre que RuntimeException, et tous les types appartiennent à la classe Exception et à ses sous-classes. Du point de vue de la syntaxe du programme, c'est une exception qui doit être gérée. Si elle n'est pas gérée, le programme ne sera pas compilé. Telles que IOException, SQLException, etc. et les exceptions définies par l'utilisateur. Généralement, aucune exception vérifiée personnalisée n'est requise.

2. Mécanisme de gestion des exceptions

Dans les applications Java, le mécanisme de gestion des exceptions est le suivant : lancer des exceptions, catch exceptions.

Lève une exception  : Lorsqu'une erreur se produit dans une méthode et qu'une exception est levée, la méthode crée un objet d'exception et le livre pour exécution. Dans le système temps réel, l'objet d'exception contient des informations telles que le type d'exception et l'état de l'exception lorsque l'exception se produit. Le système d'exécution est chargé de trouver le code permettant de gérer l'exception et de l'exécuter.

Intercepter les exceptions : Après qu'une méthode lève une exception, le système d'exécution se tourne pour rechercher un gestionnaire d'exceptions approprié. Le gestionnaire d'exceptions potentiel est l'exception qui se produit. Une collection de. méthodes qui restent dans la pile d’appels dans l’ordre. Lorsque le type d’exception que le gestionnaire d’exceptions peut gérer correspond au type d’exception émis par la méthode, il s’agit d’un gestionnaire d’exceptions approprié. Le système d'exécution démarre à partir de la méthode dans laquelle l'exception s'est produite et vérifie les méthodes dans la pile d'appels jusqu'à ce qu'il trouve la méthode contenant le gestionnaire d'exception approprié et l'exécute. Lorsque le système d'exécution parcourt la pile d'appels et ne trouve pas de gestionnaire d'exceptions approprié, le système d'exécution se termine. En même temps, cela signifie que le programme Java se termine.

En raison de la nature incontrôlable des exceptions d'exécution, afin d'implémenter les applications de manière plus raisonnable et plus simple, Java stipule que les exceptions d'exécution seront automatiquement levées par le système d'exécution Java, permettant aux applications d'ignorer les exceptions d'exécution.

Erreurs pouvant survenir lors de l'exécution de la méthode Lorsque la méthode en cours d'exécution ne veut pas l'attraper, Java permet à la méthode de ne faire aucune instruction de lancement. Parce que la plupart des exceptions d’erreur sont des situations qui ne devraient jamais se produire et que les applications raisonnables ne devraient pas détecter.

Pour toutes les exceptions vérifiables, Java stipule : Une méthode doit attraper, ou déclarer une méthode de lancement . Autrement dit, lorsqu'une méthode choisit de ne pas intercepter les exceptions vérifiables, elle doit déclarer qu'elle lèvera une exception.

De manière générale, Java stipule que les exceptions vérifiables doivent être interceptées ou déclarées comme étant levées. Permet d'ignorer les RuntimeException et les erreurs non vérifiables.

3. Attraper les exceptions : essayer, attraper et enfin

1.instruction try-catch

Une paire d'accolades après le mot-clé try Wrapping un morceau de code où des exceptions peuvent survenir est appelé zone de surveillance. Si une exception se produit lors de l'exécution d'une méthode Java, un objet exception est créé. L'exception est levée en dehors de la zone de surveillance et le système d'exécution Java tente de trouver une clause catch correspondante pour intercepter l'exception. S'il existe une clause catch correspondante, son code de gestion des exceptions est exécuté et l'instruction try-catch se termine. L'exécution du programme se poursuit.

Le principe de correspondance est le suivant : 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, l'objet d'exception généré est considéré comme correspondant au type d'exception capturé par le bloc de capture.

N'attrape ni ne déclare les exceptions d'exécution. Le programme lèvera une exception et mettra fin à l'opération.

Une fois qu'un catch détecte un type d'exception correspondant, le code de gestion des exceptions sera saisi. Une fois le traitement terminé, cela signifie que l'intégralité de l'instruction try-catch se termine. Les autres clauses catch n'ont plus la possibilité de correspondre et d'intercepter le type d'exception. Vous devriez essayer de placer la clause catch qui capture la classe d'exception de bas niveau au premier plan, et essayer de placer la clause catch qui capture la classe d'exception de niveau relativement élevé à l'arrière. Sinon, la clause catch qui capture la classe d'exception sous-jacente risque d'être bloquée.

2. try-catch-finally

L'instruction try-catch peut également inclure une troisième partie, qui est la clause finale. Il indique ce qui doit être exécuté, qu'une exception se produise ou non. La forme syntaxique générale de l'instruction try-catch-finally est la suivante :

bloc try : est utilisé pour intercepter les exceptions. Il peut être suivi de zéro ou de plusieurs blocs catch. S'il n'y a pas de bloc catch, il doit être suivi d'un bloc final.

catch block : est utilisé pour gérer les exceptions interceptées par try.

finally block : Les instructions du bloc final seront exécutées, que l'exception soit interceptée ou gérée. Lorsqu'une instruction return est rencontrée dans un bloc try ou catch, le bloc d'instructions final sera exécuté avant le retour de la méthode. Dans les 4 circonstances particulières suivantes, le bloc final ne sera pas exécuté :

1) Une exception se produit dans le bloc d'instructions final.
2) System.exit() est utilisé dans le code précédent pour quitter le programme.
3) Le thread où se trouve le programme meurt.
4) Éteignez le processeur.

3. Règles try-catch-finally (Règles de grammaire pour les instructions de gestion des exceptions) :

1) Un bloc catch ou enfin doit être ajouté après l'essai. Le bloc try peut être suivi à la fois par des blocs catch et enfin, mais il doit y avoir au moins un bloc.

2) L'ordre des blocs doit être suivi : si le code utilise à la fois des blocs catch et finalement, le bloc catch doit être placé après le bloc try.

3) Le bloc catch est lié au type de la classe d'exception correspondante.

4) Un bloc try peut avoir plusieurs blocs catch. Si tel est le cas, le premier bloc correspondant est exécuté. Autrement dit, la machine virtuelle Java fera correspondre l'objet d'exception réellement lancé avec le type d'exception déclaré tour à tour dans chaque bloc de code catch. Si l'objet d'exception est une instance d'un certain type d'exception ou de sa sous-classe, le bloc de code catch sera exécuté. et aucun autre ne sera exécuté. Le bloc de code catch

5) La structure try-catch-finally peut être imbriquée.

6) Dans la structure try-catch-finally, les exceptions peuvent être à nouveau levées.
7) Sauf dans les situations suivantes, final sera toujours exécuté à la fin : La JVM se termine prématurément (l'appel de System.exit(int)) ; une exception non gérée est levée dans le bloc final ; éteint, incendie ou attaque de virus.

4. L'ordre d'exécution des blocs d'instructions try, catch et enfin :

1) Lorsque try n'attrape pas d'exception : les instructions du bloc d'instructions try sont exécutées une par une, et le programme ignorera le bloc d'instructions catch et exécutera le bloc d'instructions enfin et les instructions suivantes

2) Lorsque try Une exception est interceptée et que l'exception n'est pas gérée dans le bloc d'instruction catch : lorsqu'une exception se produit dans une instruction du bloc d'instruction try et qu'il n'y a pas de bloc d'instruction catch pour gérer l'exception, l'exception sera levée à la JVM pour le traitement, instruction final Les instructions du bloc seront toujours exécutées, mais les instructions après le bloc d'instructions final ne seront pas exécutées

3) Lorsque try intercepte une exception, il existe une situation où gérer cette exception dans le bloc d'instructions catch : dans le bloc d'instructions try sont exécutés en séquence Lorsqu'une exception se produit lorsqu'une certaine instruction est exécutée, le programme passera au bloc d'instructions catch et fera correspondre les blocs d'instructions catch un par un pour trouver. le gestionnaire correspondant. Les autres blocs d'instructions catch ne seront pas exécutés, et dans le bloc d'instructions try, les instructions après l'exception ne seront pas exécutées. Une fois le bloc d'instructions catch exécuté, les instructions du bloc d'instructions final sont exécutées, et enfin. les instructions après le bloc d'instructions final sont exécutées

Illustration de l'exécution des blocs d'instructions try, catch et final :

5. Lancer des exceptions

Tout code Java peut lancer des exceptions, telles que : du code écrit par vous-même, du code à partir du package de l'environnement de développement Java ou du système d'exécution Java. N'importe qui peut lever une exception via l'instruction throw de Java. Toute exception levée depuis une méthode doit utiliser une clause throws.

1. throws renvoie une exception

Si une méthode peut lever une exception mais n'a pas la capacité de le faire gérer le Les exceptions peuvent être déclarées à l'aide de la clause throws lors de la déclaration de la méthode.

Les levées Exception1,Exception2,...,ExceptionN après le nom de la méthode sont la liste des exceptions à lever. Lorsqu'une méthode lève une exception à partir de la liste d'exceptions, la méthode ne gère pas les exceptions de ces types et de leurs sous-classes, mais les renvoie à la méthode qui appelle la méthode pour la gestion.

Lance des règles pour lancer des exceptions :

1) S'il s'agit d'une exception non vérifiée, c'est-à-dire Error, RuntimeException ou leur sous-classe, alors vous pouvez déclarer que l'exception est levée sans utiliser le mot-clé throws. La compilation se déroulera toujours sans problème, mais elle sera lancée par le système au moment de l'exécution.

2) Toutes les exceptions vérifiées que la méthode peut lever doivent être déclarées. Autrement dit, si une méthode peut avoir une exception vérifiable, utilisez soit une instruction try-catch pour l'attraper, soit une instruction de clause throws pour la lancer, sinon cela provoquera une erreur de compilation

3) Uniquement lorsque une exception est levée, seul l'appelant de cette méthode doit gérer ou relancer l'exception. Lorsque l'appelant de la méthode est incapable de gérer l'exception, il doit continuer à la lancer

4) La méthode appelante doit suivre les règles de gestion et de déclaration de toute exception vérifiable. Si vous remplacez une méthode, vous ne pouvez pas déclarer une exception différente de celle de la méthode remplacée. Toute exception déclarée doit appartenir à la même classe ou sous-classe que l'exception déclarée par la méthode remplacée.

La base pour juger qu'une méthode peut être anormale est la suivante :

1) .

2) D'autres méthodes sont appelées et d'autres méthodes sont déclarées avec la clause throws pour lever une sorte d'exception. Si toutes les méthodes lancent les exceptions obtenues couche par couche, la JVM finira par les gérer. Le traitement est également très simple, qui consiste à imprimer le message d'exception et les informations de la pile. Si une erreur ou une RuntimeException est levée, l'appelant de la méthode peut choisir de gérer l'exception.

2. Méthodes courantes dans la classe Throwable getCause() : renvoie la raison pour laquelle l'exception a été levée. Si la cause n’existe pas ou est inconnue, null est renvoyé.

getMeage() : renvoie des informations de message anormales.

printStackTrace() : la trace de pile de l'objet est sortie dans le flux de sortie d'erreur en tant que valeur du champ System.err.

6. Exceptions courantes Java

Java fournit quelques exceptions pour décrire les erreurs fréquentes. Pour ces exceptions, certains exigent que les programmeurs effectuent un traitement de capture ou déclarent un lancer. , et certains sont automatiquement capturés par la machine virtuelle Java. Classes d'exception courantes en Java :

1. Sous-classe runtimeException : (exception non cochée)  

• java.lang.ArrayIndexOutOfBoundsException
  Exception d'index de tableau hors limites. Levé lorsque l'index du tableau est négatif ou supérieur ou égal à la taille du tableau.

• java.lang.ArithmeticException
  Exception de condition arithmétique. Par exemple : division entière par zéro, etc.

• java.lang.NullPointerException
  Exception de pointeur nul. Cette exception est levée lorsque l'application tente d'utiliser null lorsqu'un objet est requis. Par exemple : appeler la méthode d'instance de l'objet nul, accéder aux propriétés de l'objet nul, calculer la longueur de l'objet nul, utiliser l'instruction throw pour lancer null, etc.

• java.lang.ClassNotFoundException
  Rechercher une exception de classe inférieure à. Cette exception est levée lorsque l'application tente de construire une classe basée sur un nom de classe sous forme de chaîne, mais ne parvient pas à trouver le fichier de classe portant le nom correspondant après avoir parcouru CLASSPAH.

• java.lang.NegativeArraySizeException La longueur du tableau est négative

• java.lang.ArrayStoreException Le tableau contient des valeurs incompatibles. 🎜>

java.lang.SecurityException Exception de sécurité

2. IOException (exception cochée)IOException : possible en cas de fonctionnement anormal des flux d'entrée et de sortie.

EOFException Exception terminée

FileNotFoundException Exception fichier introuvable

AutresClassCastException Type classe d'exception de conversion

ArrayStoreException Exception levée lorsque le tableau contient des valeurs incompatibles

SQLException Classe d'exception de base de données d'opération

NoSuchFieldException Exception de champ introuvable

NoSuchMethodException L'exception exception levée lorsque la méthode est introuvable

NumberFormatException L'exception levée lorsque la chaîne est convertie en nombre

StringIndexOutOfBoundsException L'exception levée lorsque l'index de la chaîne est hors plage

IllegalAccessException Accès non autorisé Certains types d'exception

InstantiationException Cette exception est levée lorsque l'application tente d'utiliser la méthode newInstance() dans la classe Class pour créer une instance d'une classe, mais que l'objet de classe spécifié ne peut pas être instancié.

4. Exceptions personnalisées L'utilisation de la classe d'exception intégrée à Java peut décrire la plupart des exceptions qui se produisent lors de la programmation. De plus, les utilisateurs peuvent également personnaliser les exceptions. Les classes d'exception définies par l'utilisateur doivent uniquement hériter de la classe Exception.

L'utilisation de classes d'exception personnalisées dans un programme peut être grossièrement divisée en les étapes suivantes.

(1) Créez une classe d'exception personnalisée.
(2) Lancez un objet d'exception via le mot-clé throw dans la méthode.
(3) Si l'exception est gérée dans la méthode qui lève actuellement l'exception, vous pouvez utiliser l'instruction try-catch pour la capturer et la gérer, sinon, utilisez le mot-clé throws lors de la déclaration de la méthode pour indiquer l'exception ; à envoyer à l'appelant de la méthode, puis continuez. Passez à l'étape suivante.
(4) Intercepter et gérer les exceptions dans l'appelant de la méthode d'exception.

Résumé : Ce qui précède représente l’intégralité du contenu de cet article, j’espère qu’il sera utile à l’étude de chacun. Pour plus de didacticiels connexes, veuillez visiter le

Tutoriel vidéo Java

, le Tutoriel graphique de développement Java, le Tutoriel vidéo bootstrap !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!