POO – JAVA

Partie III
Les Exceptions & Threads

Y. I. KHAMLICHI 1
Traitement des erreurs
Les exceptions

2
 Les exceptions en Java

 Une exception est un signal indiquant que quelque chose

d’exceptionnelle s’est produit.
 Elle interrompt le flot d’exécution normal du programme
 Plutôt que de compliquer le code du traitement normal, on
traite les conditions anormales à part.
 Le traitement « normal » apparaît ainsi plus simple et lisible.
 Résoudre les problèmes d’exception soit :
 En envoyant un message
 Mettre fin au programme
 Revenir en arrière
 …

3
 Notion d'exception

En Java, les erreurs se produisent lors d'une exécution sous

la forme d'exceptions.
Une exception :
 est un objet, instance d'une classe d'exception
 provoque la sortie d'une méthode
 correspond à un type d'erreur
 contient des informations sur cette erreur

4
 Les exceptions en Java

 Parmi les exceptions prévus par Java

 Mauvaise gestion des classes : accès hors tableau, objet
non créé…
 Erreur arithmétique : division par zéro, log d’un nombre
négatif, …
 Entrée utilisateur non valide : saisie d’un texte au lieu
d’un nombre, …
 Problème de périphérique : déconnexion Wi-Fi, bourrage
papier, …
 Limitation physique : disque plein, …
 …

5
 Terminologie

 Deux solutions alors :

 laisser le programme se terminer avec une erreur,
 essayer, malgré l'exception, de continuer l'exécution
normale.
 Lever une exception consiste à signaler quelque chose
d'exceptionnel.
 Capturer l'exception consiste à essayer de la traiter.

6
 Exemples d’exceptions
de Java
Exceptions déjà rencontrées
• Division par zéro Accès hors tableau
static void main(String[] args) static void main(String[] args) {
{ int[] tab = {4, 0, -1};
int[] tab = {2, 1, 0, -1}; int i = 0;
for (int val : tab) { while (i <= tab.length) {
System.out.println(20/val); System.out.println(tab[i]);
} i++;
} }
System.out.println("done");
}

10 4
20 0
Exception in thread "main" -1
java.lang.ArithmeticException: Exception in thread "main“
/ by zero java.lang.ArrayIndexOutOfBounds
at Main.main(Main.java:7) Exception: 3
at Main.main(Main.java:6)
• L’exécution du programme est stoppée à l’erreur

7
RATTRAPER UNE EXCEPTION

8
 Traiter une exception
Capturer et traiter des exceptions
• Les blocs try{...}
• Permettent de délimiter une partie du programme dont les
opérations et appels de méthodes sont susceptibles de générer
des exceptions que l’on souhaite traiter.

• Les clauses catch(TypeException t){...}

• Placées à la suite d’un bloc try{}, elles permettent de définir le
traitement effectué lorsqu’une exception du type spécifié est
rencontrée pendant l’exécution du bloc try{}.
static void main(String[] args) {
int[] tab = {2, 1, 0, -1};
try {
for (int val : tab) {
System.out.println(20/val);
}
} catch(ArithmeticException e) {
System.out.println("Division par zéro");
}
System.out.println("done");
}
 Les clauses « catch »
Blocs try{…} catch{…}
try {
... // Code susceptible de générer une exception
...
} catch(Type1 e) { // Capture d’exceptions de type Type1 ou dérivé
... // Traitement de l’exception de Type1
...
} catch(Type2 e) { // Capture d’exceptions de type Type2 ou dérivé
... // Traitement de l’exception de Type 2
...
} catch(Type3 | Type4 e) { // Capture d’exceptions 3 et 4 ou dérivées
... // Traitement des exceptions de Type 3 et 4
}

Les blocs try{} contiennent généralement plusieurs instructions dont certaines

sont susceptibles de générer des exceptions.
Ces instructions internes peuvent même contenir d’autres blocs try{}.
Plusieurs clauses catch(){} peuvent être associées à un bloc try{}.
La première clause catch de bon type est exécutée, les autres sont ignorées.
L’ordre des clauses catch est important  il doit respecter l’ordre d’héritage.
Il est possible de générer des exceptions dans le bloc d’une clause catch.
10
 Propagation des exceptions
Propagation et capture des exceptions
static void main(String[] args) { 10
int[] tab = {2, 1, 0, -1}; 20
2 try { Division par zéro 3
for (int val : tab) { Done 4
1 System.out.println(20/val);
}
} catch(ArithmeticException e) {
System.out.println(
3 "Division par zéro");
}
4 System.out.println("Done");
}

Lorsqu’une exception intervient

1. L’exécution du programme est stoppée
2. Un bloc try{…} contenant l’appel ayant généré l’exception est recherché
• Englobant directement la ligne ayant provoqué l’exception
• Ou sinon en remontant la chaîne des méthodes appelantes
3. Le bloc catch{…} associé est exécuté pour rattraper et traiter l’exception
4. Le programme suit son cours après le bloc catch{…} exécuté
 Propagation des exceptions
Propagation et capture des exceptions
static void main(String[] args) { 10
int[] tab = { 2, 1, 0, -1 }; 20
2 try { Division par zéro 3
for (int val : tab) { Done 4
2 int res = division(20,val);
System.out.println(res);
}
} catch(ArithmeticException e) {
System.out.println(
3 "Division par zéro");
}
4 System.out.println("Done");
}

2 static int division(int a,

int b) { Bloc try{…} non trouvé dans
1 return a/b; la méthode division(). La
}
recherche continue dans la
méthode main() qui a appelé
la méthode division()
 Le bloc « finally »
Bloc finally{…}
• Un seul bloc finally{…} peut être placé après la liste des clauses catch.
Le code contenu dans ce bloc sera toujours exécuté, soit :
• Après l’exécution du bloc try{} si aucune exception n’est survenue.
• Après l’exécution d’une clause catch ayant rattrapé une exception.
• Avant la recherche d’un bloc try{} de niveau supérieur
• quand aucune clause catch de type approprié n’a été trouvée pour rattraper
une exception du bloc try{}.
• quand une exception a été lancée dans une clause catch.
try {
... // Code susceptible de lancer une exception
...
} catch(Type1 e) {
... // Traitement de l’exception de Type1
...
} finally {
... // Traitement exécuté quoi qu’il arrive
}

• Exemples d’utilisation : sauvegarder des données, libérer des ressources, …

 Capture d'une exception

Syntaxe :

try {
code surveille
} catch (typeException1 e) {
code pour « traiter » l'exception e de type typeException1
} catch (typeException2 e) {
code pour « traiter » l'exception e
} catch (typeException3 e) {
...
} finally {
code a exécuter dans tous les cas
}

14
PRODUIRE UNE EXCEPTION

15
 Lancer une exception
Lancement d’exceptions avec – throw –
• Instruction pour lancer une exception : throw e;
• e est une instance d’une classe héritant de la classe Throwable
• Exemple 1 : throw new Exception("Message d’erreur");
• Exemple 2 : throw new ArithmeticException("Division by 0");

• Spécification des exceptions lancées par une méthode

• Si une méthode peut lancer une exception, cela doit obligatoirement être
indiqué par une clause throws ClassException après la liste des
paramètres de cette méthode. (Vérifié par le compilateur)
static int division(int a, int b) throws Exception {
if (a%b != 0) {
throw new Exception("Division non entière");
}
return a/b;
}

• Toutes les exceptions doivent être spécifiées, y compris celles lancées

dans les méthodes appelées par la méthode.
• Si plusieurs types d’exceptions peuvent être lancés par une méthode, ils
sont séparés par des virgules après le throws.
 Exemple
Propagation et capture des exceptions
static void main(String[] args) {
int[] tab = {2, 1, 3, 0};
for (int val : tab) {
2 try {
2 int res = division(20,val);
System.out.println(res);
3 } catch(ArithmeticException e) {
System.out.println("Division par zéro");
3 } catch(Exception e) {
4 System.out.println(e.getMessage());
}
}
}
2 static int division(int a, int b)
throws Exception, ArithmeticException {
if (a%b != 0) {
1 throw new Exception("Division non entière");
}
return a/b;
} 10
20
Division non entière
Division par zéro
 La classe Exception de Java
La classe Exception
Exception
- String message

+ Exception() // Constructeur par défaut

+ Exception(String) // Constructeur avec un message d’erreur
+ String getMessage() // Récupérer le message d’erreur
+ void printStackTrace() // Afficher la liste des méthodes appelantes lors du throw
…

Exemple
try { Division non entière
int res = division(20,3); java.lang.Exception: Division
} catch(Exception e) { non entière
System.out.println(e.getMessage()); at Main.division(Main.java:17)
e.printStackTrace();
} at Main.main(Main.java:6)

Si une exception n’est jamais rattrapée, y compris dans la méthode main, elle
provoque l’arrêt du programme et la méthode printStackTrace() sera appelée.
 Définir une exception
Il existe de nombreuses classes d’exceptions prédéfinies en Java :

 Toute exception en Java est un objet instancié d’une sous classe

de la classe Exception
 Arbre des exceptions :
Throwable

Error Exception

java.sql.SQLException java.io.IOException RuntimeException

java.io.FileNotFoundException IllegalArgumentException

ArithmeticException NullPointerException NumberFormatException

19
 Définir une exception

 Quelques exceptions prédéfinies :

 Division par zéro : ArithmeticException

 Référence nulle : NulPointerException
 Tentative de forçage de type illégale : ClassCastException
 Tableau de taille négative : NegativeArraySizeException
 Dépassement de dimension : ArrayIndexOutOfBoundsException
 …

20
 Intérêt des exceptions

Mais pourquoi faire tout ça ?

• Le mécanisme de gestion des exceptions permet :
• De transmettre explicitement une erreur.
• De garantir son traitement dans un contexte qualifié de niveau supérieur.
• De traiter différemment une erreur selon le contexte dans lequel elle
intervient.
• D’alléger le code en regroupant dans un seul bloc try{} catch{} le
traitement de toutes les erreurs de plusieurs lignes de code
 Exemple
boolean travail(String nomFic) {
try {
ouvertureFichier(nomFic);
lectureDonnees();
} catch (FileNotFoundException e) {
System.out.println("Impossible ouvrir " + nomFic);
return false;
} catch (IOException e) {
System.out.println("Erreur lecture " + e.getMessage());
return false;
}
traitementDesDonnees();
return true;
}

22
 Définir une exception

Afin de définir une nouvelle sorte d’exception, on crée une

nouvelle classe en utilisant une déclaration de la forme suivante :

 class NouvelleException extends ExceptionDejaDefinie {}

Exemple :

 class PasDefini extends Exception{}

23
 Lever une exception

Lorsque l’on veut lever une exception, on utilise le mot clé

throw suivi de l’exception à lever,

throw new PasDefini();

Lorsqu’une exception est levée, l’exécution normale du

programme s’arrête et on saute toutes les instructions jusqu’à ce
que l’exception soit rattrapée ou jusqu’à ce que l’on sorte du
programme.

24
 Lever une exception
Exemple:
class Stop extends RuntimeException {}
public class Exception {
public static void main(String [] args) throws Stop {
Scanner cl=new Scanner(System.in);
int x = cl.nextInt();
System.out.println("Prog1");

if (x >0){ throw new Stop(); }

System.out.println("Prog2");
System.out.println("Prog3");
} l’exécution de la commande java Exception puis la saisie de la valeur 2
} (pour la variable x) produira l’affichage suivant :
Prog 1
Exception in thread "main" Stop at Arret.main(Arret.java:7)
25