Introduction aux exceptions en Java
Tags: java, exceptions, trycatch
Published: 2023-03-18 21:44:07

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 :
```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)
```Java
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)
```Java
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 :
```Java
class MonException extends Exception {
   public MonException(String message) {
      super(message);
   }
}
```

```Java
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](https://www.jmdoudoux.fr/java/dej/chap-exceptions.htm)