Les exceptions
Le langage de programmation Java utilise des exceptions pour gérer les erreurs et les autres événements exceptionnels.
Qu'est-ce qu'une exception ?
Une exception est un événement qui se produit pendant l'exécution d'un programme et qui perturbe le déroulement normal des instructions.
En Java, les exceptions sont levées explicitement : l'action de lever une exception s'appelle lancer une exception, et l'action de traiter une exception s'appelle intercepter une exception.
En Java, toutes les exceptions sont des sous-classes de la classe Exception, qui est elle-même une sous-classe de Throwable.
Java distingue deux types d'exceptions :
- Les exceptions vérifiées
- Les exceptions non vérifiées
Les exceptions vérifiées
Les exceptions vérifiées sont des conditions exceptionnelles qu'une application doit anticiper et dont elle doit pouvoir se remettre.
Un exemple d'exception vérifiée est FileNotFoundException, qui se produit lorsqu'une méthode essaie de lire un fichier qui n'existe pas.
Ce type d'exception est vérifié à la compilation : les méthodes qui lancent des exceptions vérifiées doivent l'indiquer dans leur signature, et le code qui appelle une méthode susceptible de lancer une exception vérifiée doit la traiter, sinon le code ne compilera pas.
Toutes les exceptions vérifiées sont des sous-classes de Exception qui n'étendent pas RuntimeException.
Les exceptions non vérifiées
Les exceptions non vérifiées sont des conditions exceptionnelles qu'une application ne peut généralement ni anticiper ni traiter.
Un exemple d'exception non vérifiée est NullPointerException, qui se produit lorsqu'une méthode attend une valeur non nulle mais reçoit null.
Ce type d'exception n'est pas vérifié à la compilation : les méthodes qui lancent des exceptions non vérifiées ne sont pas obligées de l'indiquer dans leur signature, et le code qui appelle une méthode susceptible de lancer une exception non vérifiée n'est pas obligé de la traiter.
Toutes les exceptions non vérifiées héritent de RuntimeException, qui est elle-même une extension d'Exception.
Lancer des exceptions
Une méthode en Java peut lancer une exception à l'aide de l'instruction throw.
Lancer une exception vérifiée
Lorsqu'une méthode lance une exception vérifiée, elle doit l'indiquer dans sa signature à l'aide du mot-clé throws, comme le montre l'exemple ci-dessous.
Le code appelant est ainsi obligé d'anticiper qu'une exception peut être lancée et de la traiter en conséquence.
public class InsufficientBalanceException extends Exception {
}
public class BankAccount {
public void withdraw(double amount) throws InsufficientBalanceException {
if (balance < amount) {
throw new InsufficientBalanceException();
}
// rest of the method implementation
}
}
Lancer une exception non vérifiée
Lorsqu'une méthode lance une exception non vérifiée, elle n'est pas obligée de l'indiquer dans sa signature, même si c'est possible.
public class BankAccount {
public void withdraw(double amount) {
if (amount < 0) {
throw new IllegalArgumentException("Cannot withdraw a negative amount");
}
// rest of the method implementation
}
}
Traiter les exceptions
En Java, le traitement des exceptions se fait à l'aide des mots-clés try, catch et finally.
- Les instructions susceptibles de lancer une exception doivent être placées dans un bloc
try.
- Le bloc
try est suivi d'un ou plusieurs blocs catch qui interceptent les exceptions lancées dans le bloc try.
- Les blocs
catch sont éventuellement suivis d'un bloc finally qui s'exécute toujours après le bloc try, qu'une exception ait été lancée ou non.
L'exemple suivant montre comment ces mots-clés fonctionnent :
public class ATM {
public void withdraw(BankAccount bankAccount, double amount) {
try {
System.out.println("Withdrawing " + amount);
bankAccount.withdraw(amount);
System.out.println("Withdrawal succeeded");
} catch (InsufficientBalanceException) {
System.out.println("Withdrawal failed: insufficient balance");
} catch (RuntimeException e) {
System.out.println("Withdrawal failed: " + e.getMessage());
} finally {
System.out.println("Current balance: " + bankAccount.getBalance());
}
}
}
Dans cet exemple, lorsqu'aucune exception n'est lancée, la sortie suivante s'affiche :
Withdrawing 10.0
Withdrawal succeeded
Current balance: 5.0
En revanche, si l'instruction bankAccount.withdraw(amount) lance une InsufficientBalanceException, la sortie suivante s'affiche :
Withdrawing 10.0
Withdrawal failed: insufficient balance
Current balance: 5.0
Ou, si une exception non vérifiée est lancée par bankAccount.withdraw(amount), la sortie suivante s'affiche :
Withdrawing -10.0
Withdrawal failed: Cannot withdraw a negative amount
Current balance: 5.0
Les erreurs
Java possède aussi une catégorie distincte appelée Errors : ce sont des problèmes graves externes à l'application.
Un exemple d'erreur est OutOfMemoryError, qui se produit lorsqu'une application essaie d'utiliser plus de mémoire que le système n'en dispose.
Comme les exceptions non vérifiées, les erreurs ne sont pas vérifiées à la compilation.
La différence est qu'elles représentent des problèmes au niveau du système et sont généralement lancées par la machine virtuelle Java ou par l'environnement plutôt que par l'application.
Les applications ne devraient généralement pas essayer de les intercepter ni de les traiter.
En Java, toutes les erreurs héritent de la classe Error.
Exercice d'apprentissage
