Exceptions Java et comment les gérer

En tant que développeur Java, vous devez avoir une bonne connaissance des exceptions Java et de la gestion des exceptions.

Ce didacticiel fournit les connaissances de base que tout programmeur doit posséder lorsqu'il travaille avec des programmes Java. Pour commencer, commençons par comprendre ce que sont exactement les exceptions Java.



Que sont les exceptions Java

Un programme Java peut rencontrer des problèmes qui entraînent l'arrêt brutal du programme lors de son exécution. Ces problèmes sont appelés exceptions.


Un bon programmeur doit être capable de reconnaître les erreurs qui peuvent survenir lors de l'exécution et de fournir des itinéraires alternatifs que le programme doit emprunter en cas d'une telle exception. Cette pratique s'appelle la gestion des exceptions.

Maintenant, vous vous demandez peut-être pourquoi nous avons besoin de la gestion des exceptions. Pourquoi ne pas écrire des programmes qui ne lancent pas d’exceptions?




Pourquoi avons-nous besoin d'une gestion des exceptions

En fin de compte, écrire des programmes qui ne lancent pas d’exceptions n’est pas aussi simple qu’il y paraît. La plupart du temps, ces erreurs inévitables sont hors du contrôle du programmeur.

Les programmes qui acceptent l'entrée de l'utilisateur sont susceptibles de rencontrer des exceptions en raison d'une entrée non valide fournie par l'utilisateur. Il en va de même pour la lecture de fichiers externes en tenant compte de la possibilité qu'ils aient été déplacés, renommés ou supprimés par une source extérieure à l'insu du programmeur.

Dans de tels cas, le programme doit être en mesure de gérer l'exception correctement sans terminer l'exécution.



Hiérarchie des exceptions Java

Toutes les exceptions en Java doivent être un enfant de Exception classe, qui est elle-même un enfant de Throwable classer.


Deux sous-classes principales de Exception classe sont RuntimeException et IOException.



Exception vs erreur

Une autre classe enfant de Throwable la classe est la Error classer. Cependant, les erreurs sont différentes des exceptions.

Les erreurs indiquent des problèmes que la JVM peut rencontrer lors de l'exécution. Ces problèmes sont généralement critiques et irrécupérables. Les fuites de mémoire et les problèmes d'incompatibilité de bibliothèque sont des raisons courantes d'erreurs dans les programmes.

StackOverflowError et OutOfMemoryError sont deux exemples d'erreurs Java.




Exceptions cochées et non cochées

Nous pouvons diviser les exceptions Java en deux catégories principales: vérifié et décoché exceptions.

Les exceptions cochées sont les exceptions qui doivent être gérées dans le programme avant la compilation. Si ces exceptions ne sont pas gérées, le programme ne sera pas compilé par le compilateur Java. Par conséquent, celles-ci sont également appelées exceptions au moment de la compilation. IOExceptions sont de bons exemples d'exceptions vérifiées.

Les exceptions non vérifiées sont les exceptions que le compilateur ignore lors de la compilation du programme. Que nous ayons traité ces exceptions dans le programme ou non n'a pas d'importance au moment de la compilation du programme. Étant donné que la gestion des exceptions n'est pas imposée à ces exceptions, notre programme peut se heurter à RuntimeExceptions qui entraînent l'arrêt du programme.

Toutes les classes qui étendent le RuntimeException class sont des exceptions non vérifiées. Deux exemples de telles classes sont NullPointerException et ArrayIndexOutOfBoundsException.




Méthodes couramment utilisées dans la classe d'exception

Nous allons passer en revue quelques méthodes couramment utilisées dans Java Exception classer:

  1. getMessage: renvoie un message contenant des détails sur l'exception qui s'est produite.
  2. printStackTrace: renvoie la trace de pile de l'exception survenue.
  3. toString: renvoie le nom de la classe et le message renvoyé avec getMessage méthode.


Comment gérer les exceptions

Voyons comment nous pouvons gérer les exceptions en Java:

essayer-attraper

Nous pouvons attraper les exceptions et les gérer correctement en utilisant un essayer-attraper block en Java.

Dans cette syntaxe, la partie du code qui est susceptible de lever une exception est placée dans un bloc try et le / les blocs catch attrapent les exceptions / exceptions levées et les gèrent selon une logique que nous fournissons.


La syntaxe de base d'un bloc try-catch est la suivante:

try {
//exception-prone code } catch(Exception e) {
//error handling logic }

Avec cette approche, le programme n'interrompt pas l'exécution lorsqu'une exception est levée par le programme, au lieu de cela, elle est gérée correctement.

Nous allons voir comment gérer les IOExceptions lancé par le FileReader classe dans un programme Java.

Exemple:

import java.io.FileReader; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();
}
catch(Exception e) {

e.printStackTrace();
}
} }

Ici, nous avons utilisé un seul bloc catch pour gérer FileNotFoundException jeté lors de l'instanciation de FileReader classe et IOException lancé par le read() méthode du FileReader classer.

Ces deux exceptions sont des enfants de Exception classer.

Nous pouvons également utiliser plusieurs instructions catch pour intercepter différents types d'erreurs générées par le code à l'intérieur de l'instruction try unique. Pour l'exemple précédent, nous pouvons utiliser un bloc catch pour attraper le FileNotFoundException et un autre bloc catch pour le IOException comme le montre l'extrait de code suivant:

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();

file.close();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
} }

Si l'exception levée correspond à l'exception gérée par la première instruction catch, elle est ensuite gérée par la logique à l'intérieur de la première instruction catch.

Si les exceptions ne correspondent pas, elle est transmise à la deuxième instruction catch. S'il y a plus de deux instructions catch, ce processus se poursuit jusqu'à ce que l'exception atteigne une instruction catch qui intercepte son type.

Depuis FileNotFoundException est un sous-type de IOException, utilisant la 2ème instruction catch pour attraper un FileNotFoundException ne fonctionnera pas. Il sera traité par la première instruction catch et n'atteindra jamais la deuxième instruction.

Noter:Il est obligatoire d'utiliser au moins une instruction catch avec une instruction try.

finalement

Lorsque nous utilisons un essayer-attraper block pour intercepter les exceptions dans notre programme, il y a des instances que nous voulons implémenter une logique malgré le fait qu'une exception ait été interceptée ou non. Dans de tels cas, nous pouvons utiliser un essayer-attraper-enfin bloquer au lieu de juste un essayer-attraper bloquer.

Ensuite, le code à l'intérieur du finally est implémentée, qu'une exception se produise ou non. Le finally L'instruction doit toujours venir à la fin du bloc try-catch-finally.

Par exemple, lorsque nous utilisons le FileReader classe pour lire un fichier, il est indispensable de fermer le fichier ouvert à la fin du traitement, qu'une exception se produise ou non. Pour garantir cela, nous pouvons placer le code pour fermer le fichier dans un finally déclaration.

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;
try {

file = new FileReader('source.txt');

file.read();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
finally {

file.close();
}
} }

Cependant, si vous essayez de compiler le code ci-dessus, le code ne sera pas compilé en raison d'un IOException non géré. C'est parce que le close() méthode du FileReader classe peut également lancer IOExceptions. Nous devons donc placer cette partie dans un autre bloc try comme celui-ci:

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;

try {

file = new FileReader('source.txt');

file.read();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
finally {

try {


file.close();

}

catch(IOException e) {


e.printStackTrace();

}
}
} }

jette

Gestion des erreurs à l'aide de throws mot-clé en Java est simple. En fait, dans cette approche, vous ne gérez pas vraiment l'exception à l'endroit où elle se produit. Au lieu de cela, nous lançons l'exception de la méthode actuelle à la méthode qui a appelé la méthode actuelle. Ensuite, remettre l'erreur devient une responsabilité de la méthode externe.

Pour lever une exception d'une méthode, vous devez simplement déclarer que cette méthode peut lever l'exception considérée. Voyons comment nous pouvons gérer IOExceptions lancé par le FileReader classe en utilisant cette approche.

Exemple:

import java.io.FileReader; import java.io.IOException; public class ThrowsExample {
public void readFile throws IOException {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
} }

lancer

Contrairement aux autres approches de cette liste, le throw Le mot clé n'est pas utilisé pour gérer les erreurs. Mais comme la plupart des gens confondent le throw mot-clé avec throws mot-clé, nous avons pensé qu'il serait préférable d'en discuter ici.

Le throw Le mot clé est utilisé pour invoquer explicitement une exception. Nous pouvons lancer une exception nouvellement instanciée ou une exception qui a été interceptée à l'intérieur de la méthode.

public class ThrowExample {
public void invalidate(int amount) throws Exception {
if (amount < 500) {

throw new Exception('Amount not sufficient');
}
} }


Exceptions définies par l'utilisateur

En plus d'utiliser les exceptions Java intégrées, vous pouvez définir vos propres exceptions. Vous pouvez les définir comme des exceptions cochées ou non cochées. Pour créer une nouvelle exception vérifiée, votre nouvelle exception doit étendre le Exception classer.

Pour créer un non vérifié exception, étendez le RuntimeException classer.

Dans l'exemple de code suivant, nous avons créé une exception vérifiée définie par l'utilisateur:

public class InvalidLengthException extends Exception {
private int length;
private String message;
public InvalidLengthException(int length, String message) {
this.length=length;
this.message=message;
}
public int getAmount() {
return this.length;
}
public String getMessage() {
return this.message;
} }

Maintenant, nous pouvons utiliser l'exception ci-dessus dans notre logique de programme comme ceci:

public class InputChecker {
private int minLength;
private int maxLength;
public InputChecker(int minLength, int maxLength) {
this.minLength=minLength;
this.maxLength=maxLength;
}
public void checkStringLength(String strInput) throws InvalidLengthException {
int strLength = strInput.length();
if (strLength maxLength){

throw new InvalidLengthException(strLength, 'Input should have maximum '+maxLength+' character');
}
} }

Si nous vérifions la longueur d'une chaîne en utilisant le InputChecker classe, il lancera un InvalidLengthException si la longueur de la chaîne est inférieure à la longueur minimale ou supérieure à la longueur maximale.

public class Main {
public static void main(String[] args) {
InputChecker ic = new InputChecker(2, 7);
try {

ic.checkStringLength('longer than the maximum length');
}
catch(InvalidLengthException e) {

e.printStackTrace();
}
} }

Lorsque nous exécutons l'extrait de code ci-dessus, il lancera un InvalidLengthException et nous obtiendrons la sortie suivante:

InvalidLengthException: Input should have maximum 7 character
at InputChecker.checkStringLength(InputChecker.java:17)
at Main.main(Main.java:6)


Conclusion

Dans ce didacticiel, nous vous avons présenté une introduction rapide et concise aux exceptions Java. Nous espérons que vous avez maintenant une bonne compréhension de ce que sont les exceptions et comment les gérer dans votre programme Java.