Cours Programmation

Java avancée

Dr. Inès THABET

Chapitre Gestion des exceptions

2
Plan du chapitre Gestion des
exceptions
 Gestion des exceptions
 Le bloc try-catch
 Les types d’exceptions
 Finally
 Propagation des exceptions

3
 La gestion des erreurs en java
 Tout programme comporte des erreurs (bugs) ou est susceptible
de générer des erreurs (suite à une action de l’utilisateur, de
l’environnement, etc ...).
 Une exception désigne tout ce qui produit durant l’exécution
d’un programme interrompant son fonctionnement normal
(condition d'erreur inattendue ).
public static void main(java.lang.String[] args) {
int i = 3; int j = 0;
System.out.println("résultat = " + (i / j)); }
 Si cette exception n'est pas interceptée, l'exécution du programme
prend fin.
C:>java TestException Exception in thread "main"
java.lang.ArithmeticException: / by zero 4
La gestion des erreurs en Java
 Le langage Java propose un mécanisme particulier pour gérer les
erreurs : les exceptions. Ce mécanisme repose sur deux
principes :
 1. Les différents types d’erreurs sont modélisées par des classes.
 2. Les instructions susceptibles de générer des erreurs sont séparées
du traitement de ces erreurs : concept de bloc d’essai et de bloc de
traitement d’erreur.

5
 Les exceptions
 En java, les exceptions sont matérialisées par des instances de
classes héritant de la classe java.lang.Throwable. A chaque
évènement correspond une sous-classe précise, ce qui peut
permettre d’y associer un traitement approprié.

sous classes sont checked exceptions

sous classes sont unchecked

exceptions
6
 Gestion des exceptions avec
try-catch
 Pour gérer les exceptions :
 Placer le code qui lève les exceptions dans un bloc try.
 Placer le code qui gère une exception dans un bloc catch.
 Il est possible d’avoir plusieurs blocs catch pour chaque bloc
try. Chaque bloc catch gère un type d'exception spécifique.
 Un bloc try doit avoir au moins un bloc catch ou un bloc
finally associé.

7
 Les blocs try
 La clause try s’applique à un bloc d’instructions
correspondant au fonctionnement normal mais pouvant
générer des erreurs.
 Attention : un bloc try ne compile pas si aucune de ses
instructions n’est susceptible de lancer une exception.
public static void main(java.lang.String[] args) {
int i = 3; int j = 0;
try {
System.out.println("résultat = " + (i / j));
}

8
 Les blocs catch
 La clause catch définit le traitement d’un type d’erreur. Il sera lancé
sur une instance de la classe d’exception passée en paramètre.
 Si l'exception générée est une instance de la classe déclarée dans la
clause catch ou d'une classe dérivée, alors on exécute le bloc associé.
 Il faut mettre les clauses catch pour traiter en premier les
exceptions les plus précises (sous-classes) avant les
exceptions plus générales. Un message d'erreur est émis par le
compilateur dans le cas contraire.
public static void main(java.lang.String[] args) {
int i = 3; int j = 0;
try {
System.out.println("résultat = " + (i / j));}
catch (Exception e) { }
catch (ArithmeticException e) { } }
catch (ArithmeticException e) { }
catch (Exception e) { } } 9
 Les blocs : try-catch
 L'exécution totale du bloc try et d'un bloc catch sont exclusives.
Un ensemble composé d’un bloc try et d’au moins un bloc catch est
communément appelé bloc try-catch. Il fonctionne :
1. Si aucune des instructions du bloc d’essai ne lance d’exception, il est
entièrement exécuté et les blocs de traitement d’erreur sont ignorés.
2. Si une des instructions du bloc d’essai lance une exception, alors toutes
les instructions du bloc d’essai après elle sont ignorées et le premier bloc
de traitement d’erreur correspondant au type d’exception lancée. Tous les
autres blocs de traitement d’erreur sont ignorés.

10
Les blocs catch

try{
I1 ;
I2 ;
I3 ; }
catch(Exception1 e1){ T11;
}
catch(Exception2 e2){ T21;
T22; }
catch(Exception3 e3){ . . . }
finally{
F; }

11
Hiérarchie des exceptions

12
La classe throwable

Throwable() Le constructeur par défaut.

Le constructeur avec un
Throwable(String message) paramètre, le message de
l'exception.
Le constructeur avec une cause
Throwable(Throwable cause)
en paramètre.
Throwable(String message, Le constructeur avec un message
Throwable cause) et une cause.

13
La classe throwable

Méthode Description
String getMessage() Retourne le message
Imprime le contenu de la pile
void printStackTrace()
dans le fichier d’erreur err
void printStackTrace Imprime le contenu de la pile
(PrintStream s) dans s
void Imprime le contenu de la pile
printStackTrace(PrintWriter s) dans s
String toString()
…….. ……
PrintStream : System.out, System.err
PrintWriter : flux de sortie 14
Les exceptions de type Error

 Les exceptions de type Error sont réservées aux erreurs qui

surviennent dans le fonctionnement de la JVM. Elles
peuvent survenir dans toutes les portions du codes. Exemple
de sous-classes :
 OutOfMemoryError : survient lorsque la machine virtuelle n’a plus
de place pour faire une allocation et que le garbage collector ne peut
en libérer.
 NoSuchMethodError : survient lorsque la machine virtuelle ne
peut trouver l’implémentation de la méthode appelée.
 StackOverflowError : survient lorsque la pile déborde après une
série d’appel récursif trop profond.
 etc...
15
Les exceptions de type Error

 StackOverflowError
 private static int fibonacci(int number) {
return fibonacci(number - 1) + fibonacci(number - 2);
}
Exception in thread "main"
java.lang.StackOverflowError at
MainUnCheckedException.fibonacci(MainUnCheckedEx
ception.java:10)

16
 Les exceptions de type Runtime

 Les exceptions de type RuntimeException correspondent à des

erreurs qui peuvent survenir dans toutes les portions du codes et
qui ne peuvent pas être vérifiées lors de la compilation .
 Une erreur de programmation (NullPointerException) est
“unchecked” (sinon, il faudra toujours traiter cette erreur car elle
peut intervenir partout!)
 ArithmeticException : division par zéro (entiers), etc
 IndexOutOfBoundsException : dépassement d’indice dans un
tableau.
 NullPointerException : référence null alors qu’on attendait une
référence vers une instance.
 etc...
17
Les exceptions de type Runtime

int a = 0;
try {
int x = 1 /a;
System.out.println(" x = " + x); }
catch (ArithmeticException e) {
System.out.println("division par 0 : 1 / " + a); }

18
 Les exceptions contrôlées
 Une exception contrôlée : conditions pour lesquelles on peut
raisonnablement espérer pouvoir récupérer et poursuivre
l’exécution.
 Force le développeur à gérer une condition exceptionnelle (éviter
qu’il ne la néglige trop)
 Toute exception qui hérite de la classe Exception et qui n’est pas
une RuntimeException. Elle est dite contrôlée car le compilateur
vérifie que toutes les méthodes l’utilisent correctement.
 Le JDK définit de nombreuses exceptions : EOFException : fin de
fichier.
 FileNotFoundException : erreur dans l’ouverture d’un fichier.
 ClassNotFoundException : erreur dans le chargement d’une
classe. etc... 19
Les exceptions contrôlées
 FileNotFoundException
public class MainCheckedException {
public static void main(String[] args) {
FileInputStream fileInputStream = new FileInputStream("foo.txt");
}}
Error:(6, 43) java: unreported exception
java.io.FileNotFoundException; must be caught or declared to be
thrown

20
 Gestion des exceptions
 Toute exception contrôlée, du JDK ou personnalisée, pouvant être
émise dans une méthode doit être :
 Soit levée dans cette méthode. Elle est alors lancée dans un bloc try
auquel est associé un catch lui correspondant.
 Soit être indiquées dans le prototype de la méthode à l’aide du mot
clé throws. Ces erreurs doivent être déclarées dans la signature de la
fonction si elles ne sont pas capturées par la fonction.
 La clause throws indique également que toute méthode qui l'appelle
devra prendre en compte cette exception (traitement ou
propagation).
 Si la méthode appelante ne traite pas l'erreur ou ne la propage pas, le
compilateur génère l'exception nom_exception must be caught or it
must be declared in the throws clause of this method. 21
Le contrôle des exceptions :
traitement local
public void f() {
try {
FileInputStream monFichier ; // Ouvrir un fichier peut
//générer une exception
monFichier = new FileInputStream("./essai.txt"); }
catch (FileNotFoundException e)
{ System.out.println(e); }
}
public static void main(String[] args) {
f();
} 22
Le contrôle des exceptions :
trows
 Clause throws : déclarer une méthode où on peut anticiper l’échec.
public void f() throws FileNotFoundException {
FileInputStream monFichier ; // Ouvrir un fichier peut générer une except
monFichier = new FileInputStream("./essai.txt"); }
public static void main(String[] args) {
try { // Un appel a f() peut générer une exception
f(); }
catch (FileNotFoundException e)
{ System.out.println(e); } }
 Dans la déclaration, on peut grouper les erreurs dans une super
classe, ou bien les lister.
public void write(Object obj, String filename) throws IOException,
23
nullPointerException
 Les exceptions contrôlées
personnalisées
 On peut définir ses propres exceptions héritent classe Exception.
 public class MonException extends Exception {
private int x;
public MonException(int x) { this.x = x; }
public String toString() { return "Valeur incorrecte : " + x; } }

 La clause throw : permet de lever une exception manuellement en

instanciant un objet de type Exception (ou un objet hérité).

24
 Les exceptions personnalisées
 Lancer les exceptions : la clause throw
class TestTableau {
public void main (String args) { Exécution
java TestTableau 3 Taille du tableau : 3
try {
int size = Integer.parseInt(args[0]); java TestTableau -1 Valeur incorrecte : -1
if (size < 0)
{ throw new MonException(size); }
int[] tab = new int[size] ;
System.out.println("Taille du tableau :" + tab.length); }
catch (MonException e) {
System.err.println(e); } } }
25
Les exceptions contrôlées
personnalisées
public class SaisieErroneeException extends Exception {
public SaisieErroneeException() { super(); }
public SaisieErroneeException(String s) { super(s); } }
public class TestSaisieErroneeException {
public static void controle(String chaine) throws SaisieErroneeException
{ if (chaine.equals(""))
throw new SaisieErroneeException("Saisie erronée : chaine vide"); }
public static void main(java.lang.String[] args) {
String chaine1 = "";
try {
controle(chaine1); }
catch (SaisieErroneeException e) {
System.out.println("Chaine1 saisie erronee"); } 26
La clause Finally
 La clause finally définit un bloc d’instruction qui sera exécuté
même si une exception est lancée dans le bloc d’essai. Elle permet
de forcer la bonne terminaison d’un traitement en présence
d’erreur.
 Le bloc finally est toujours exécuté, qu'une exception soit levée ou
non:
 Si la clause try ne lance pas d’exception : exécution après le try.
 Si la clause try lance une exception traitée par un catch : exécution
après le catch.
 Si la clause try lance une exception non traitée par un catch :
exécution après le lancement de l’exception.
 Le bloc finally est souvent utilisé pour écrire du code
de nettoyage.
 Attention : Un appel de System.exit() dans le bloc try ou dans un
bloc catch arrête l’application sans passer par la clause finally. 27
La clause Finally
 class TestTableau {
public void main (String args) {
try {
int x = -1;
if (x < 0)
{throw new MonException(x);} Exécution
System.out.println(x); } java TestTableau -1 Valeur
incorrecte : -1
catch (MonException e) { Tout est bien qui ...
System.err.println(e); }
finally {
System.out.println("Tout est bien qui ..."); } } } 28
 Traiter une exception

 Pour traiter une exception, on distingue finalement trois

méthodes :
 1. Traitement local : l’exception est levée dans la méthode .
 2. Traitement délégué : l’exception, qui n’est pas levée dans la
méthode, est transmise à la méthode appelante.
 3. Traitement local partiel : l’exception est levée dans la
méthode, puis re-lancée pour être transmise à la méthode
appelante.

29
Traiter une exception : Traitement
délégué
 public void f() throws FileNotFoundException {
monFichier = new FileInputStream("./essai.txt"); }
public void g() {
try {
f(); }
catch (FileNotFoundException e) {
System.err.println("Traitement délégué à g"); } }

Exécution
Traitement délégué à g
30
 Traitement local partiel

 public void f() throws FileNotFoundException {

try {
monFichier = new FileInputStream("./essai.txt"); }
catch (FileNotFoundException e) {
System.err.println("Traitement local par f");
throw e; } } Exécution
public void g() { Traitement local par f
try { Traitement délégué à g
f(); }
catch (FileNotFoundException e)
{ System.err.println("Traitement délégué à g"); } } 31
 Traitement des exceptions
 Lorsqu'un événement que la JVM ne sait pas gérer apparaît, une
exception est levée (exemple : division par zéro). Une exception
correspond donc à une erreur.
 Si une exception remonte jusqu’à la méthode main sans être
traitée par cette méthode, l’exécution du programme est stoppée, le
message associé à l’exception est affiché, avec une description de la pile
des méthodes traversées par l’exception.
 La superclasse qui gère les exceptions s'appelle Exception.
 Vous pouvez créer une classe d'exception personnalisée : faites-lui
hériter de la classe Exception.
 L'instruction qui permet de capturer des exceptions est le
bloc try{…}catch{}. 32
Traitement des exceptions
 Si une exception est levée dans le bloc try, les instructions figurant
dans le bloc catch seront exécutées pour autant que celui-ci
capture la bonne exception levée.
 Vous pouvez ajouter autant de blocs catch que vous le voulez à la
suite d'un bloc try, mais respectez l'ordre : du plus pertinent au
moins pertinent.
 Dans une classe objet, vous pouvez prévenir la JVM qu'une
méthode est dite « à risque » grâce au mot clé throws.
 Vous pouvez définir plusieurs risques d'exceptions sur une même
méthode. Il suffit de séparer les déclarations par une virgule.

33
Traitement des exceptions
 Dans cette méthode, vous pouvez définir les conditions
d'instanciation d'une exception et lancer cette dernière grâce au
mot clé throw suivi de l'instanciation.
 Une instanciation lancée par le biais de l'instruction throw doit
être déclarée avec throws au préalable !

34