Comprendre la hiérarchie des exceptions en Java expliqué

e terme « Exception » est l'abréviation de « événement exceptionnel ». En Java, une exception est essentiellement un événement qui se produit pendant l'exécution d'un programme et perturbe le déroulement normal du programme. Les exceptions sont indésirables et pour la plupart inattendues, elles surviennent généralement au moment de l'exécution ou de la compilation. Toutes ces exceptions doivent être gérées pour garantir que le programme s'exécute dans son flux naturel.

Cependant, avant de gérer les exceptions, il serait utile de savoir quels différents types d'exceptions sont présents avec Java. À travers cet article, examinons les différents types d'exceptions en Java et la hiérarchie des exceptions qu'elles suivent.

Hiérarchie des exceptions en Java

La hiérarchie des exceptions dans le langage de programmation Java commence par la classe Throwable - qui vient de la classe Object et est sa sous-classe directe, tandis que la classe Exception présente toutes les branches de cette classe Throwable en deux sous-classes - Error et Exception. Voici un organigramme pour mieux comprendre la hiérarchie des exceptions Java :

La classe Exception présente toutes les exceptions que vous devrez peut-être gérer lorsque vous travaillez avec le langage de programmation Java. Certains exemples couramment connus et rencontrés de telles exceptions incluent NullPointerException, ClassNotFoundException, IllegalArgumentException, etc.

D'autre part, la classe Error s'occupe des problèmes plus graves dans l'architecture de votre programme Java et n'est pas prise en charge dans le code de l'application. Quelques exemples d'erreurs en Java sont InternalError, AssertionError, OutOfMemoryError, etc.

Les exceptions en Java sont divisées en deux catégories :

• Exceptions vérifiées - Celles-ci sont également appelées exceptions au moment de la compilation.
• Exceptions non vérifiées - Celles-ci sont également appelées exceptions d'exécution.

Un point important à noter à ce stade est que les exceptions non contrôlées sont toutes des sous-classes de la classe RuntimeException. Nous parlerons plus en détail des exceptions cochées et non cochées plus loin dans cet article. Mais avant cela, regardons essentiellement comment les erreurs et les exceptions diffèrent dans leur fonctionnement afin qu'il n'y ait pas de confusion.

Erreurs et exceptions en Java - En quoi diffèrent-elles ?

La documentation officielle du langage de programmation Java fait référence aux erreurs comme des occurrences au cours de votre programmation Java qui "indiquent des problèmes graves qu'une application raisonnable ne devrait pas essayer de détecter". La gravité des erreurs ressort clairement de la façon dont cette déclaration est posée. De toute évidence, cela fait référence à l'ensemble des problèmes auxquels votre programme peut être confronté et dont il ne peut pas se remettre sans refactoriser le code ou modifier l'architecture de l'application Java.

Regardons une méthode Java qui va générer une erreur :

public static void print(String S) {

impression(S);

}

Dans le code mentionné ci-dessus, la méthode print() agit comme une méthode récursive qui s'appelle de façon répétée, encore et encore, jusqu'à ce qu'elle atteigne la taille maximale autorisée pour une pile de threads en Java. À ce stade, il quitte l'exécution avec un très commun - StackOverflowError, qui lit quelque chose comme :

Exception dans le fil "principal" java.lang.StackOverflowError

à StackOverflowErrorExample.print(StackOverflowErrorExample.java:3)

Comme le montre l'exemple ci-dessus, la méthode lance un exemple, mais cette erreur ne peut pas être gérée dans le code lui-même. Ainsi, le programme quitte simplement l'exécution car les dommages sont irrécupérables. Comme solution, le code doit être modifié.

Contrairement aux erreurs, les exceptions indiquent des conditions qui peuvent être détectées par une application raisonnable. Les exceptions en Java incluent les problèmes qui peuvent survenir au moment de la compilation ou pendant l'exécution. Ces exceptions se produisent assez fréquemment dans toutes les applications, en particulier pendant la phase de test et de débogage. Par conséquent, les exceptions en Java peuvent être gérées dans le programme lui-même pour garantir que le code exécute son flux naturel.

Maintenant, parlons un peu plus de la hiérarchie des exceptions en Java en examinant ce que sont les exceptions cochées et non cochées.

Exceptions cochées et non cochées en Java

Comme mentionné précédemment, les exceptions dans un programme Java peuvent se produire pendant la compilation ou pendant l'exécution. C'est ce qui nous donne les deux grands types d'exceptions présentes en Java. Examinons ces deux exceptions en détail.

Exceptions au moment de la compilation

Les exceptions qui se produisent au moment de la compilation sont appelées exceptions au moment de la compilation. Celles-ci sont également appelées exceptions vérifiées car vous devez les vérifier explicitement dans votre programme Java et les gérer dans le code lui-même. Des classes telles que InterruptedException, IOException, etc. sont des exceptions vérifiées.

Regardons une méthode qui peut gérer une exception vérifiée :

public void writeAFile() {

essayez (BufferedWriter b_w = new BufferedWriter(new FileWriter("myFile.txt"))) {

b_w.write("Test");

} capture (IOException ioe) {

ioe.printStackTrace();

}

}

Comme vous pouvez le voir, il y a deux déclarations dans le bloc try du code ci-dessus -

• Instanciation de l'objet – BufferedWriter
• Utilisation de l'objet pour écrire dans le fichier

Ces deux instructions peuvent lever IOException. IOException, étant une exception vérifiée, doit être gérée soit par l'appelant, soit par la méthode. Dans l'exemple ci-dessus, vous pouvez voir l'exception gérée dans la méthode elle-même.

Exceptions d'exécution

Contrairement aux exceptions au moment de la compilation qui sont levées au moment de la compilation, les exceptions d'exécution ou non contrôlées peuvent être levées "à tout moment", ce qui signifie essentiellement au moment de l'exécution. En conséquence, les méthodes n'ont pas besoin d'utiliser explicitement des blocs catch-and-throw pour gérer ces exceptions non contrôlées. Certaines des classes qui héritent des exceptions d'exécution non contrôlées incluent - NullPointerException, ArithmeticException, etc.

Regardons un morceau de code Java qui lève une exception non vérifiée NullPointerException et qui n'est pas géré dans le morceau de code contrairement au précédent. C'est ici:

public void writeToFile() {

essayez (BufferedWriter b_w = null) {

b_w.write("Tester");

} capture (IOException ioe) {

ioe.printStackTrace();

}

}

Lorsque vous appelez la méthode ci-dessus, le programme lèvera une NullPointerException car l'objet BufferedWriter est nul. Voici à quoi ressemblerait l'exception :

Exception dans le thread "principal" java.lang.NullPointerException

à IOExceptionExample.writeToFile(IOExceptionExample.java:10)

à IOExceptionExample.main(IOExceptionExample.java:17)

En conclusion

Avec cela, nous arrivons à la fin de ce blog sur la compréhension de la hiérarchie des exceptions en Java. Veuillez garder à l'esprit qu'il ne s'agit en aucun cas d'une couverture complète des exceptions en Java et de la manière de les gérer. Pour cela, vous devez creuser plus profondément et vous exposer à différentes exceptions possibles pour voir comment elles fonctionnent. Connaître la gestion des exceptions vous préparera à une carrière réussie en tant que développeur full-stack puisque les exceptions constituent la base de toute application.

Chez upGrad, nous avons un cours spécialisé de développement de pile complète - Programme exécutif PG en développement de logiciels - Spécialisation en développement de pile complète - où nous vous expliquons toutes les nuances du développement de logiciel en nous concentrant principalement sur le développement de pile complète. Nous vous suggérons de consulter le cours et probablement de réserver une place bientôt !