---
title: JAVA - 09. La gestion des exceptions
tags: POO
---
## Gestion d'exceptions
Lorsqu’on développe des applications en Java ou dans n’importe quel autre langage informatique, on va forcément faire face aux erreurs. Même après avoir corrigé son application grâce aux tests unitaires, il y’a des situations où les bugs sont inévitables.
la sécurité d'une application peut être rendue instable par toute une série de facteurs :
- Des problèmes liés au matériel : par exemple la perte subite d'une connexion à un port, un disque défectueux...
- Des actions imprévues de l'utilisateur. Par exemple, vous ne pouvez pas toujours compter sur le fait que l’utilisateur n’essaiera pas d’effectuer une division par 0.
- Des débordements de stockage dans les structures de données...
Pendant l'exécution d'un programme, les faiblesses peuvent survenir :
- lors des entrées-sorties,
- lors de calculs mathématiques interdits (comme la division par zéro),
- lors de fausses manœuvres de la part de l’utilisateur,
- ou encore lorsque la connexion à un périphérique est inopinément interrompue,
- lors d'actions sur les données.
Le programme doit donc se **défendre** contre de tels incidents potentiels, on appel cette démarche **la programmation défensive**.
:::info
**La programmation défensive** est une attitude de pensée consistant à prévoir que le logiciel sera soumis à des défaillances dues à certains paramètres externes ou internes et donc à prévoir une réponse adaptée à chaque type de situation.
L’objectif principal est d’améliorer la qualité de **robustesse** d’un programme.
:::
En programmation défensive il est possible de protéger directement le code à l’aide de **la notion d’exception**.
L’utilisation des exceptions avec leur mécanisme intégré, autorise la construction rapide et efficace de logiciels robustes.
## Rôle d'une exception
Les exceptions représentent le mécanisme de gestion des erreurs intégré au langage Java.
Une exception est chargée de **signaler un comportement exceptionnel** (mais prévu) d’une partie spécifique d’un programme.
Ce mécanisme se compose d'objets représentant les erreurs et d'un ensemble de mots clés qui permettent de détecter et de traiter ces erreurs mais aussi de les lever ou les propager.
Lors de la détection d'une erreur, un objet qui hérite de la classe **Exception** est créé (on dit qu'**une exception est levée**) et propagé à travers la pile d'exécution jusqu'à ce qu'il soit traité.
Par exemple, si on exécute le programme suivant:
```java=
public class TestExceptions {
public static void main(String[] args) {
String str = null;
int len = str.length();
}
}
```
on obtient une sortie telle que la suivante:
```java=
Exception dans le thread "principal" java.lang.NullPointerException
à test.TestExceptions.main(TestExceptions.java:4)
```
Si une exception se produit sans être capturée nulle part, le programme se termine et affiche un message donnant le type de l’exception ainsi qu’une **trace de la pile** (**stack trace**).
Si notre programme a appelé plusieurs méthodes avant de rencontrer un problème, **la trace de la pile** peut nous aider à suivre la trace de notre programme et à trouver la ligne qui a causé l'erreur.
Elle montre la séquence des appels de méthodes effectués jusqu'au moment où l'erreur d'exécution s'est produite.
## Hiérarchie des exceptions en java
En Java, les exceptions sont représentées par des objets de classe **Throwable** dans le package **java.lang**. C'est la classe de base pour le traitement des erreurs.
Elle a deux sous-classes **Error** et **Exception**:
- La classe **Error** représente une erreur grave intervenue dans la machine virtuelle Java ou dans un sous système Java. L'application Java s'arrête instantanément dès l'apparition d'une exception de ce type. Ces exceptions sont considérées comme **non récupérables**, les appelants n'ont pas à les gérer explicitement.
- La classe **Exception** représente des erreurs moins graves, elle est considérée comme récupérable.
Cependant, les objets de la sous-classe **RuntimeException** d'Exception **ne sont pas obligatoirement récupérables**. Ces exceptions sont dites **non contrôlées (unchecked)** parce que le compilateur ne vérifie pas comment elles sont traitées. Elle comporte les exceptions: ArithmeticException, ArrayStoreException, NullPointerException, IndexOutOfBoundsException, ...
Les autres sous-classes de la classe **Exception** sont formées d'exceptions qui **doivent être récupérées** tel que: FileNotFoundException, UnknownHostException, InterruptedException, etc. Ces exceptions sont dites **contrôlées (checked)** parce que le compilateur vérifie comment elles sont traitées.
:::info
Les exceptions définies par le programmeur sont des sous-classes de **Exception**, elles sont donc contrôlées.
:::
## Interception et traitement des exceptions avec try/catch
Lorsqu’une portion de code est susceptible de lancer/lever une exception, il est possible de capturer cette potentielle exception et indiquer le traitement qui doit en être fait.
La capture d’une exception en Java se fait à l’aide du bloc de mots clés **try … catch**
```java=
try {
// les instructions susceptibles de provoquer des exceptions
// incluant éventuellement des appels de methodes
} catch (ExceptionType ex ) {
//les instructions pour gérer cette exception
//(lignes de code réagissant à l’exception ExceptionType)
}
```
Le **bloc try** rassemble les appels de méthodes susceptibles de produire des erreurs ou des exceptions.
Si un événement indésirable survient dans le **bloc try**, la partie non exécutée de ce bloc est abandonnée et le **bloc catch** est traité.
:::info
Le type **ExceptionType** est obligatoirement une classe qui hérite de la classe **Exception**.
:::
Par exemple, l'exécution du programme suivant:
```java=
public static void main(String[] args) {
int tab[] = {1,2,3,4};
try{
tab[4] = 3;
} catch(ArrayIndexOutOfBoundsException ex ){
System.out.println("Erreur d'index");
}
}
```
affiche à la console Erreur d’index:
```java=
Java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
at TestException.main(...)
```
:::info
Si aucune des instructions du bloc **try** ne lance une exception, le programme ignore la clause **catch**.
:::
## Gérer des exceptions multiples
On peut capturer des exceptions multiples dans un bloc **try** et les gérer ensuite différemment.
Il faut utiliser dans ce cas une **clause catch spécifique à chaque type d'exception**.
Ce mécanisme fonctionne comme un **sélecteur ordonné**, ce qui signifie qu'une **seule clause d'interception est exécutée**.
Dans l’exemple suivant, on prend les deux entrées de type int de l’utilisateur, puis les divisons pour afficher le résultat.
```java=
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
try {
System.out.println("num1: ");
int num1 = sc.nextInt();
System.out.println("num2: ");
int num2 = sc.nextInt();
int dividedNum = num1 / num2;
System.out.println("Résultat de la division: " + dividedNum);
} catch (InputMismatchException e1) {
System.out.println("Erreur! - Entrez un numéro.");
} catch (ArithmeticException e2) {
System.out.println("Erreurr! - Division par 0");
}
}
```
Plusieurs exceptions peuvent être levées comme *InputMismatchException* lorsque la valeur saisie n’est pas de type int et **ArithmeticException** lorsque num2 obtient la valeur zéro car aucun nombre n’est divisé par zéro.
Pour les intercepter toutes les deux, on ecrit deux blocs catch différents avec leurs types d’exception.
Chaque bloc catch est **spécifique à un type d'exception** et englobant le tratement approprié .
:::info
lorsqu’il y a une hiérarchie entre les exceptions à intercepter, on choisira de placer le code de leurs blocs catch dans **l’ordre inverse de la hiérarchie**.
:::
### Gérer plusieurs exceptions dans un bloc catch:
A partir Java SE 7, on peut désormais intercepter plusieurs types d'exceptions dans un **seul bloc catch** en leur applicant le même traitement.
Chaque type d'exception pouvant être gérée par le bloc catch est séparé à l'aide d'une pipe **|**.
```java=
try {
// code
} catch (ExceptionType1 | Exceptiontype2 ex) {
// catch block
}
```
La capture de plusieurs exceptions dans un seul bloc catch réduit la duplication de code et augmente l'efficacité.
Le bytecode généré lors de la compilation de ce programme sera plus petit que le programme ayant plusieurs blocs catch car il n'y a pas de redondance de code. Comme le montre l'exemple suivant:
```java=
public static void main(String[] args) {
try {
int array[] = new int[10];
array[10] = 30 / 0;
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
```
## Clause Finally
Une clause **finally** est généralement incluse pour s’assurer que certaines opérations de nettoyage (par exemple, la fermeture des fichiers ouverts) sont effectuées.
Une clause **finally** s’exécute **toujours** lorsque son bloc **try** s’exécute (qu’il y ait ou non une exception).
```java=
public static void main(String[] args) {
int tab[] = {1,2,3,4};
try{
tab[4] = 3;
} catch(ArrayIndexOutOfBoundsException ex ){
System.out.println("Erreur d'index");
}finally{
System.out.println("Les instructions du bloc Finally");
}
System.out.println("Suite du programme");
}
```
Voici les situations qui peuvent se présenter :
- Aucune exception ne se produit pendant l’exécution du try. **La clause finally s’exécute, puis la suite du programme**.
- Aucune exception ne se produit pendant l’exécution du try, mais le block try contient un **transfert de contrôle** (return, break, continue, throw). **La clause finally s’exécute, puis le transfert de contrôle aura lieu**.
- Une exception se produit pendant l’exécution du try, et il existe une clause catch pour cette exception. **La clause catch s’exécute, puis la clause finally, puis le reste du programme**.
- Une exception se produit pendant l’exécution du try, mais il n’y a pas de clause catch pour cette exception. **La clause finally s’exécute, puis l’exception non attrapée est levée**.
- Une exception se produit pendant l’exécution du try, il y a une clause catch pour cette exception, et la clause catch exécute un transfert de contrôle. **La clause catch s’exécute, puis la clause finally, puis le transfert de contrôle a lieu**.
## Déclenchement des exceptions
Il est possible de déclencher soi-même des exceptions en utilisant l'instruction **throw**, voir même de déclencher des exceptions personnalisées ou non
La JVM peut aussi lever (déclencher/lancer) une exception à votre demande suite à la rencontre d'une instruction throw.
La syntaxe est:
```java=
throw new ExceptionALever();
```
Les sous-classes de Throwable possèdent un second constructeur qui accepte un argument de type chaîne. On peut en profiter pour décrire plus en détail la situation d’exception:
```java=
throw new ExceptionALever("message explicatif");
```
Comme le montre l'exemple suivant:
```java=
public static void main(String args[]){
// Déclencher (lever) l'exception NullPointerException
throw new NullPointerException("demo");
}
```
Ou encore son équivalent:
```java=
public static void main(String args[]){
// instancier un objet de type NullPointerException
NullPointerException ex= new NullPointerException("demo");
// Déclencher (lever) l'exception de type NullPointerException
throw ex;
}
```
Ici, NullPointerException est une exception non contrôlée. Il n'est généralement pas nécessaire de gérer les exceptions non contrôlées.
Dans le cas d'une exception controlée:
```java=
public static void main(String[] args) {
try {
// Déclencher l'exception de type IOException
throw new IOException("File not found");
System.out.println("le reste du code du bloc Try");
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
```
puisqu'il s'agit d'une exception vérifiée (contrôlée), le compélateur nous force à l'intercepter avec le bloc try catch.
Il est possible de repropager une exception qui a été gérée par une instruction catch en utilisant le mot clé throw:
```java=
try {
// Déclencher l'exception de type IOException
throw new IOException("File not found");
System.out.println("le reste du code du bloc Try");
} catch (IOException e) {
throw e;
}
```
## Propager une Exception
Le déclenchement d'une exception provoque d'une part la sortie immédiate de la méthode, et d'autre part le dépilage des appels jusqu'à ce qu'apparaisse un cadre d'invocation d'une méthode contenant un catch.
L'exception est donc propagée le long de la chaîne des invocations tant qu'elle n'est pas récupérée.
Ce mécanisme de propagation est distinct du mécanisme usuel de retour d'une méthode. Si l'exception n'est jamais récupérée, le programme termine anormalement.
**throws** est un mot clé en Java qui est utilisé dans **la signature de la méthode** pour indiquer que cette méthode peut lever l'une des exceptions de type verifiées.
```java=
type method_name(parameters) throws exception_list
// exception_list est une liste séparée par des virgules de tous les
// exceptions qu'une méthode peut lever.
```
L'appelant de cette méthode doit gérer l'exception à l'aide:
- Soit d'un bloc **try-catch**
- Soit en utilisant le mot clé **throws**
Dans le programme suivant, en utilisant le mot-clé throws, on a géré **InterruptedException**:
```java=
// Déléguer une exception de type IllegalAccessException
static void fun() throws IllegalAccessException{
System.out.println("Inside fun(). ");
// Déclencgerv une exception de type IllegalAccessException
throw new IllegalAccessException("demo");
}
public static void main(String args[]){
try{
fun();
}
catch(IllegalAccessException e){
System.out.println("caught in main.");
}
}
```
## Exception personnalisée
Java nous offre la possibilité de créer nos propres exceptions qui sont essentiellement des classes dérivées de la classe **Exception**.
La création de notre propre exception est connue sous le nom d'**exception personnalisée**.
Fondamentalement, les exceptions personnalisées sont utilisées pour personnaliser l'exception en fonction des besoins de l'utilisateur.
Afin de créer une **exception personnalisée**, on doit étendre la classe **Exception** qui appartient au package **java.lang**.
Par exemple, la classe MonException dans le code ci-dessous étend la classe Exception:
```java=
// La lasse representant une exception personalisée
class MonException extends Exception {
public MonException(String s)
{
// Appel du constructeur de la classe mère
super(s);
}
}
// La lasse utilisant une exception personalisée
public class Main {
public static void main(String args[]) {
try {
// Déclencher l'exception personalisée MonException
throw new MyException("message");
}
catch (MyException ex) {
// afficher le message de l'objet MonException
System.out.println(ex.getMessage());
}
}
}
```
### Pourquoi utiliser des exceptions personnalisées ?
Les exceptions Java couvrent presque tous les types généraux d'exceptions qui peuvent survenir dans la programmation. Cependant, nous devons parfois créer des exceptions personnalisées
pour des raisons suivantes:
- Pour intercepter et fournir un traitement spécifique à un sous-ensemble d'exceptions Java existantes.
- Exceptions de logique métier : il s'agit des exceptions liées à la logique métier et au workflow. Il est utile pour les utilisateurs de l'application ou les développeurs de comprendre le problème exact.
## Instruction try-with-resources
Des ressources comme des fichiers, des flux, des connexions, ... doivent être fermées explicitement par le développeur pour libérer les ressources sous-jacentes qu'elles utilisent.
Généralement cela est fait en utilisant un bloc **finally** pour garantir leur fermeture dans la quasi-totalité des cas.
A partir Java 7, l'instruction **try avec ressource** permet de définir une ressource qui sera automatiquement fermée à la fin de l'exécution du bloc de code de l'instruction.
Ce mécanisme est aussi désigné par l'acronyme **ARM** (Automatic Ressource Management).
Sa syntaxe est:
```java=
try (resource declaration) {
// Utilisation de la ressource
} catch (ExceptionType ex) {
// catch block
}
```
Comme le montre la syntaxe ci-dessus, on déclare l'instruction **try-with-resources** par:
1. déclarer et instancier la ressource dans la **clause try**.
2. spécifiant et gérant, dans le bloc **catch**, toutes les exceptions qui pourraient être levées lors de la fermeture de la ressource.
:::info
:bulb: L'instruction **try-with-resources** ferme toutes les ressources qui implémentent l'interface **AutoCloseable** .
:::
Prenons un exemple qui implémente l'instruction try-with-resources:
```java=
public static void main(String[] args) {
String line;
try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
while ((line = br.readLine()) != null) {
System.out.println("Line =>"+line);
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
```
Dans cet exemple, on a déclaré et instancié le BufferedReader à l'intérieur de l'instruction try-with-resources pour garantir que son instance soit fermée dans le cas où l'instruction try se termine normalement ou dans le cas d'une exception.
Sign in with Wallet
Connect another wallet