Introduction aux exceptions en Java

Les exceptions sont l'un des concepts les plus importants en Java, car elles permettent de gérer les erreurs et les comportements inattendus dans les programmes Java. Dans cet article, nous allons discuter de ce que sont les exceptions en Java, comment les gérer, et nous allons illustrer tout cela par des exemples.

Qu'est-ce qu'une exception en Java ?

En Java, une exception est un événement qui se produit lorsqu'un programme rencontre une erreur ou un comportement inattendu qui l'empêche de continuer normalement.

Les types d'exceptions en Java

En Java, il existe deux types d'exceptions : les exceptions vérifiées (checked exceptions) et les exceptions non vérifiées (unchecked exceptions).

• Les exceptions vérifiées sont des exceptions qui doivent être gérées dans le code du programme. Elles sont appelées vérifiées car le compilateur Java vérifie si elles sont correctement gérées dans le code du programme. Si une exception vérifiée n'est pas gérée correctement, le programme ne sera pas compilé.

• Les exceptions non vérifiées sont des exceptions qui ne sont pas vérifiées par le compilateur Java. Elles sont appelées non vérifiées car le compilateur ne vérifie pas si elles sont correctement gérées dans le code du programme. Les exceptions non vérifiées sont généralement des erreurs de programmation, telles que les erreurs de division par zéro ou les erreurs de pointeur nul.

Comment gérer les exceptions en Java

En Java, les exceptions sont gérées à l'aide de blocs try-catch. Le bloc try contient le code qui peut générer une exception. Si une exception est générée dans le bloc try, l'execution du code qui s'y trouve s'interrompt, et le programme passera directement au bloc catch.

Le bloc catch contient le code qui gère l'exception. Il doit avoir le même type d'exception que celle qui est générée dans le bloc try. Si l'exception générée dans le bloc try n'est pas attrapée par un bloc catch correspondant, elle sera propagée vers le bloc catch suivant dans la pile d'appels, ou elle sera propagée jusqu'à ce qu'elle atteigne le bloc catch par défaut.

Le bloc finally est optionnel, il contient le code qui doit être exécuté qu'il y ait une exception ou non. Le code placé dans le bloc finally sera exécuté après le bloc try et le bloc catch, quel que soit le résultat.

Voici un exemple simple pour comprendre la syntaxe des blocs try-catch-finally en Java :

try {
   // code qui peut générer une exception
} catch (TypeException e) {
   // code qui gère l'exception
} finally {
   // code qui est toujours exécuté, qu'il y ait une exception ou non
}

Exemples d'exceptions en Java

Voici quelques exemples d'exceptions en Java :

1. Exception de division par zéro (ArithmeticException)

try {
   int a = 1 / 0;
} catch (ArithmeticException e) {
   System.out.println("Erreur : Division par zéro !");
}

Dans cet exemple, le code dans le bloc try tente de diviser le nombre entier 1 par 0, ce qui générera une exception de division par zéro (ArithmeticException). Le bloc catch attrape cette exception et affiche un message d'erreur approprié.

2. Exception de pointeur nul (NullPointerException)

try {
   String s = null;
   int length = s.length();
} catch (NullPointerException e) {
   System.out.println("Erreur : Pointeur nul !");
}

Dans cet exemple, le code dans le bloc try tente d'appeler la méthode length() sur une chaîne de caractères nulle, ce qui générera une exception de pointeur nul (NullPointerException). Le bloc catch attrape cette exception et affiche un message d'erreur approprié.

3. Exception personnalisée

Il est également possible de créer des exceptions personnalisées en Java en créant une classe qui étend la classe Exception ou RuntimeException. Voici un exemple de création d'une exception personnalisée :

class MonException extends Exception {
   public MonException(String message) {
      super(message);
   }
}

try {
   throw new MonException("Une erreur personnalisée s'est produite !");
} catch (MonException e) {
   System.out.println(e.getMessage());
}

Dans cet exemple, nous avons créé une exception personnalisée appelée MonException en étendant la classe Exception. Nous avons ensuite créé une instance de cette exception en utilisant le mot-clé throw, puis nous avons attrapé cette exception dans le bloc catch et affiché le message d'erreur approprié.

Conclusion

En comprenant les types d'exceptions en Java,vous pourrez mieux gérer les erreurs et les comportements inattendus dans vos programmes Java.

Pour aller plus loin: https://www.jmdoudoux.fr/java/dej/chap-exceptions.htm