Gestion des exceptions en Java est l'un des moyens efficaces pour gérer les erreurs d'exécution afin que le flux régulier de l'application puisse être préservé. Java Exception Handling est un mécanisme permettant de gérer les erreurs d'exécution telles que ClassNotFoundException, IOException, SQLException, RemoteException, etc.
Que sont les exceptions Java ?
En Java, exception est un événement indésirable ou inattendu, qui se produit lors de l’exécution d’un programme, c’est-à-dire au moment de l’exécution, qui perturbe le flux normal des instructions du programme. Les exceptions peuvent être interceptées et gérées par le programme. Lorsqu'une exception se produit dans une méthode, elle crée un objet. Cet objet est appelé objet d'exception. Il contient des informations sur l'exception, telles que le nom et la description de l'exception ainsi que l'état du programme au moment où l'exception s'est produite.
Principales raisons pour lesquelles une exception se produit
- Entrée utilisateur invalide
- Panne de l'appareil
- Perte de connexion réseau
- Limitations physiques (mémoire disque insuffisante)
- Erreurs de code
- Ouvrir un fichier indisponible
les erreurs représentent des conditions irrécupérables telles qu'un manque de mémoire de la machine virtuelle Java (JVM), des fuites de mémoire, des erreurs de débordement de pile, une incompatibilité de bibliothèque, une récursivité infinie, etc. Les erreurs échappent généralement au contrôle du programmeur et nous ne devons pas essayer de gérer les erreurs.
Différence entre erreur et exception
Discutons de la partie la plus importante qui est la différences entre erreur et exception c'est le suivant :
- Erreur: Une erreur indique un problème sérieux qu’une application raisonnable ne devrait pas tenter de détecter.
- Exception: L'exception indique des conditions qu'une application raisonnable pourrait tenter de détecter.
Hiérarchie des exceptions
Tous les types d'exceptions et d'erreurs sont des sous-classes de la classe Jetable , qui est la classe de base de la hiérarchie. Une branche est dirigée par Exception . Cette classe est utilisée pour les conditions exceptionnelles que les programmes utilisateur doivent détecter. NullPointerException est un exemple d'une telle exception. Une autre branche, Erreur est utilisé par le système d'exécution Java ( JVM ) pour indiquer les erreurs liées à l'environnement d'exécution lui-même (JRE). StackOverflowError est un exemple d'une telle erreur.
Hiérarchie des exceptions Java
Types d'exceptions
Java définit plusieurs types d'exceptions liées à ses différentes bibliothèques de classes. Java permet également aux utilisateurs de définir leurs propres exceptions.
Les exceptions peuvent être classées de deux manières :
- Exceptions intégrées
- Exception vérifiée
- Exception non vérifiée
- Exceptions définies par l'utilisateur
Discutons de l'exception répertoriée ci-dessus qui est la suivante :
1. Exceptions intégrées
Les exceptions intégrées sont les exceptions disponibles dans les bibliothèques Java. Ces exceptions permettent d'expliquer certaines situations d'erreur.
- Exceptions vérifiées : Les exceptions vérifiées sont appelées exceptions au moment de la compilation car ces exceptions sont vérifiées au moment de la compilation par le compilateur.
- Exceptions non vérifiées : Les exceptions non cochées sont juste à l’opposé des exceptions cochées. Le compilateur ne vérifiera pas ces exceptions au moment de la compilation. En termes simples, si un programme lève une exception non vérifiée, et même si nous ne la gérons pas ou ne la déclarons pas, le programme ne générera pas d’erreur de compilation.
Note: Pour les exceptions cochées et non cochées, voir Exceptions vérifiées et non vérifiées
2. Exceptions définies par l'utilisateur :
Parfois, les exceptions intégrées à Java ne sont pas capables de décrire une certaine situation. Dans de tels cas, les utilisateurs peuvent également créer des exceptions, appelées « exceptions définies par l'utilisateur ».
Le avantages de la gestion des exceptions en Java sont les suivants:
- Disposition pour terminer l’exécution du programme
- Identification facile du code de programme et du code de gestion des erreurs
- Propagation des erreurs
- Rapport d'erreur significatif
- Identification des types d'erreurs
Méthodes pour imprimer les informations sur l'exception :
1. printStackTrace()
Cette méthode imprime les informations sur l'exception au format Nom de l'exception : description de l'exception, trace de pile.
Exemple:
Java
//program to print the exception information using printStackTrace() method> > import> java.io.*;> > class> GFG {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >e.printStackTrace();> >}> >}> }> |
>
>
Sortir
java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>
2. toString()
La méthode toString() imprime les informations sur l'exception au format Nom de l'exception : description de l'exception.
Exemple:
Java
//program to print the exception information using toString() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.toString());> >}> >}> }> |
en ordre
>
>
Sortir
java.lang.ArithmeticException: / by zero>
3. getMessage()
La méthode getMessage() imprime uniquement la description de l'exception.
Exemple:
Java
//program to print the exception information using getMessage() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.getMessage());> >}> >}> }> |
>
>
Sortir
/ by zero>
Comment la JVM gère-t-elle une exception ?
Gestion des exceptions par défaut : Chaque fois qu'à l'intérieur d'une méthode, si une exception s'est produite, la méthode crée un objet appelé objet d'exception et le transmet au système d'exécution (JVM). L'objet exception contient le nom et la description de l'exception ainsi que l'état actuel du programme dans lequel l'exception s'est produite. La création de l'objet d'exception et sa gestion dans le système d'exécution s'appelle lancer une exception. Il peut y avoir une liste des méthodes qui ont été appelées pour accéder à la méthode où une exception s'est produite. Cette liste ordonnée de méthodes est appelée Pile d'appels . La procédure suivante va maintenant se produire.
- Le système d'exécution recherche dans la pile d'appels la méthode qui contient un bloc de code capable de gérer l'exception survenue. Le bloc du code est appelé un Gestionnaire d'exceptions .
- Le système d'exécution commence la recherche à partir de la méthode dans laquelle l'exception s'est produite et parcourt la pile d'appels dans l'ordre inverse dans lequel les méthodes ont été appelées.
- S'il trouve un gestionnaire approprié, il lui transmet l'exception survenue. Un gestionnaire approprié signifie que le type d’objet d’exception lancé correspond au type d’objet d’exception qu’il peut gérer.
- Si le système d'exécution recherche toutes les méthodes sur la pile d'appels et n'a pas pu trouver le gestionnaire approprié, alors le système d'exécution transmet l'objet d'exception au gestionnaire d'exceptions par défaut , qui fait partie du système d'exécution. Ce gestionnaire imprime les informations d'exception dans le format suivant et termine le programme anormalement .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>
Regardez le diagramme ci-dessous pour comprendre le flux de la pile d'appels.
Illustration:
Java
// Java Program to Demonstrate How Exception Is Thrown> > // Class> // ThrowsExecp> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Taking an empty string> >String str =>null>;> >// Getting length of a string> >System.out.println(str.length());> >}> }> |
>
>
Sortir
Voyons un exemple qui illustre comment un système d'exécution recherche le code de gestion des exceptions approprié sur la pile d'appels.
Exemple:
Java
// Java Program to Demonstrate Exception is Thrown> // How the runTime System Searches Call-Stack> // to Find Appropriate Exception Handler> > // Class> // ExceptionThrown> class> GFG {> > >// Method 1> >// It throws the Exception(ArithmeticException).> >// Appropriate Exception handler is not found> >// within this method.> >static> int> divideByZero(>int> a,>int> b)> >{> > >// this statement will cause ArithmeticException> >// (/by zero)> >int> i = a / b;> > >return> i;> >}> > >// The runTime System searches the appropriate> >// Exception handler in method also but couldn't have> >// found. So looking forward on the call stack> >static> int> computeDivision(>int> a,>int> b)> >{> > >int> res =>0>;> > >// Try block to check for exceptions> >try> {> > >res = divideByZero(a, b);> >}> > >// Catch block to handle NumberFormatException> >// exception Doesn't matches with> >// ArithmeticException> >catch> (NumberFormatException ex) {> >// Display message when exception occurs> >System.out.println(> >'NumberFormatException is occurred'>);> >}> >return> res;> >}> > >// Method 2> >// Found appropriate Exception handler.> >// i.e. matching catch block.> >public> static> void> main(String args[])> >{> > >int> a =>1>;> >int> b =>0>;> > >// Try block to check for exceptions> >try> {> >int> i = computeDivision(a, b);> >}> > >// Catch block to handle ArithmeticException> >// exceptions> >catch> (ArithmeticException ex) {> > >// getMessage() will print description> >// of exception(here / by zero)> >System.out.println(ex.getMessage());> >}> >}> }> |
>
>Sortir
/ by zero>
Comment un programmeur gère-t-il une exception ?
Gestion des exceptions personnalisée : La gestion des exceptions Java est gérée via cinq mots-clés : essayer , attraper , lancer , jette , et enfin . En bref, voici comment ils fonctionnent. Les instructions de programme qui, selon vous, peuvent déclencher des exceptions sont contenues dans un bloc try. Si une exception se produit dans le bloc try, elle est levée. Votre code peut intercepter cette exception (en utilisant le bloc catch) et la gérer de manière rationnelle. Les exceptions générées par le système sont automatiquement levées par le système d'exécution Java. Pour lever manuellement une exception, utilisez le mot-clé throw. Toute exception rejetée par une méthode doit être spécifiée comme telle par une clause throws. Tout code qui doit absolument être exécuté une fois un bloc try terminé est placé dans un bloc final.
Conseil: Il faut passer par contrôlez le flux dans try catch enfin bloquer pour une meilleure compréhension.
Nécessité d'une clause try-catch (gestion personnalisée des exceptions)
Considérez le programme ci-dessous afin de mieux comprendre la clause try-catch.
Exemple:
âge de mia khalifa
Java
// Java Program to Demonstrate> // Need of try-catch Clause> > // Class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Taking an array of size 4> >int>[] arr =>new> int>[>4>];> > >// Now this statement will cause an exception> >int> i = arr[>4>];> > >// This statement will never execute> >// as above we caught with an exception> >System.out.println(>'Hi, I want to execute'>);> >}> }> |
>
>
Sortir
Explication de la sortie : Dans l'exemple ci-dessus, un tableau est défini avec une taille, c'est-à-dire que vous ne pouvez accéder aux éléments que de l'index 0 à 3. Mais vous essayez d'accéder aux éléments à l'index 4 (par erreur), c'est pourquoi il lève une exception. Dans ce cas, JVM termine le programme anormalement . L'instruction System.out.println(Bonjour, je veux exécuter); ne s'exécutera jamais. Pour l'exécuter, nous devons gérer l'exception en utilisant try-catch. Par conséquent, pour continuer le déroulement normal du programme, nous avons besoin d’une clause try-catch.
Comment utiliser la clause Try-Catch ?
try { // block of code to monitor for errors // the code you think can raise an exception } catch (ExceptionType1 exOb) { // exception handler for ExceptionType1 } catch (ExceptionType2 exOb) { // exception handler for ExceptionType2 } // optional finally { // block of code to be executed after try block ends }> Certains points clés sont à retenir qui sont les suivants :
- Dans une méthode, il peut y avoir plusieurs instructions susceptibles de lever une exception. Placez donc toutes ces instructions dans leur propre essayer bloquer et fournir un gestionnaire d'exceptions distinct au sein de leur propre attraper bloc pour chacun d’eux.
- Si une exception se produit dans le essayer bloc, cette exception est gérée par le gestionnaire d’exceptions qui lui est associé. Pour associer le gestionnaire d'exceptions, il faut mettre un attraper bloquer après. Il peut y avoir plusieurs gestionnaires d’exceptions. Chaque attraper block est un gestionnaire d'exceptions qui gère l'exception au type indiqué par son argument. L'argument ExceptionType déclare le type d'exception qu'il peut gérer et doit être le nom de la classe qui hérite du Jetable classe.
- Pour chaque bloc try, il peut y avoir zéro ou plusieurs blocs catch, mais seulement un bloc final.
- Le bloc final est facultatif. Il est toujours exécuté, qu'une exception se soit produite dans le bloc try ou non. Si une exception se produit, elle sera exécutée après essayez d'attraper des blocs. Et si aucune exception ne se produit, elle sera exécutée après le essayer bloc. Le bloc final en Java est utilisé pour mettre des codes importants tels que le code de nettoyage, par exemple la fermeture du fichier ou la fermeture de la connexion.
- Si nous écrivons System.exit dans le bloc try, alors le bloc final ne sera pas exécuté.
Le résumé est représenté via l’aide visuelle ci-dessous comme suit :
Articles Liés:
- Types d'exceptions en Java
- Exceptions vérifiées et non vérifiées
- Lancements en Java
Cours connexes
Fondation de programmation Java – Cours à votre rythme
Trouvez le cours qui vous convient pour commencer à apprendre Java Programming Foundation auprès d'experts du secteur ayant des années d'expérience. Ce Fondation de programmation Java – Cours à votre rythme couvre les principes fondamentaux du Langage de programmation Java, types de données, opérateurs et contrôle de flux, boucles, chaînes , et beaucoup plus. Plus besoin d'attendre ! Commencez à apprendre JAVA maintenant et devenez un ingénieur Java complet !