Chapitre 6 traitement des exceptions

Cours POO (Java) - 51 - Amir Souissi © 2018
CHAPITRE 6
TRAITEMENT DES EXCEPTIONS

Chapitre 6 Traitement des Exceptions
1. Introduction
La mise en place du traitement des exceptions permet aux programmes d’intercepter et de
gérer les erreurs au lieu de les laisser se produire et d’en subir les conséquences.
Le traitement des exceptions est destiné à gérer les conditions de fonctionnement
exceptionnelles (problème et dysfonctionnement à la source de l’exception).
Il existe deux types d’erreurs :
I. Erreurs synchrones : ce sont des erreurs qui peuvent être pris en charge localement
dans la programme.
Exemples :
• Dépassement des limites d’un tableau par un indice
• Dépassement arithmétique = valeur en dehors de l’échelle de valeurs représentables
• Tentative de division par zéro
• Des paramètres de méthode non valide
II. Erreurs asynchrones : ces sont des erreurs non conventionnelles qui ne peuvent pas
être pris en charges par le programme.
Exemples :
• Epuisement de la mémoire
• Achèvement des opérations d’entrée sortie sur disque (ouverture d’un fichier, etc.)
• Arrivée de message de réseau
• Les clics sur la souris
• La pression de touche et ainsi de suite.
On a alors plusieurs avantages de l’utilisation du traitement des exceptions :
• Améliorer la clarté du programme et en faciliter la modification.
• Eviter la fin brutale du programme qui peut laisser une ressource dans un état non
réutilisable.
• Eviter l’oublie de certains cas exceptionnels ou leurs mauvais traitements.
L’inconvénient majeur du traitement des exceptions c’est qu’il affiche une lenteur
certaine par rapport au traitement local. Alors, si une erreur est traitable localement au lieu
de lancer une exception, traitez-la. (exemple, tentative de division par zéro)
La procédure de récupération s’appelle un gestionnaire d’exception
Le gestionnaire d’exception peut se définir dans une méthode qui provoque une exception
ou dans une méthode appelante de celle-ci = c’est un code qui s’exécute lorsque le
programme détecte une exception.

2. Principe du traitement des exceptions en Java
Les exceptions sont des objets de classes qui dérivent d’une superclasse Exception.
Lorsqu’une méthode détecte une erreur, on dit qu’elle lève ou lance une exception.
Si le gestionnaire d’exception existe, alors il intercepte (ou capture) l’exception et la
traite.
Dans le cas où le gestionnaire d’exception adéquat n’existe pas, alors Java provoque la
sortie immédiate, après la fin de l’exécution du gestionnaire d’exception prédéfini.
2.1. Blocs try, catch, finally
Le programmeur enferme dans un bloc try le code qui peut générer une exception.
Le bloc try est immédiatement suivi de zéro ou plusieurs blocs catch. Chaque bloc
catch spécifie le type d’exception qu’il peut intercepter et contient un gestionnaire
d’exception.
Après le dernier bloc catch, un bloc finally optionnel offre le code qui doit toujours
s’exécuter, qu’un exception donnée s’exécute ou non.
Le bloc try doit être suivi d’un bloc catch ou d’un bloc finally.
int data = 5/0 ; Objet
Exception
est traité?
Reste du code est exécutéJVM
1. Affiche la description de l’exception
2. Affiche le Stack trace
3. Termine le programme
Un objet de la classe
d’exception est levé
NON OUI

Syntaxe :
try {
//code susceptible de lever une exception
} catch ( TypeException exception1) {
//instructions du traitement de l’exception1
} catch ( TypeException exception2) {
//instructions du traitement de l’exception2
}
..... //autres blocs catch possibles
finally {
//instructions exécutées qu’une exception soit levée ou non
}
Le bloc try peut être suivi des blocs catch et finally de l’une des manières suivantes :
try catch
try finally
try catch finally
avec possibilité d’avoir plusieurs blocs catch successifs
Remarques :
Les blocs catch et finally ne peuvent pas accéder aux objets définis dans le bloc try
Un catch ne peut avoir qu’un seul paramètre.
2.2. Classes d’exception
Le package java.lang contient deux classes d’exception prédéfinies : Exception et Error
Ces deux classes héritent directement de la classe Throwable.
Les erreurs (Error) sont des problèmes graves qui ne doivent pas être capturées.
Les exceptions (Exception) sont provoquées par des problèmes qui doivent être
interceptés et traités pendant l’exécution du programme.

Figure 6.1. Hiérarchie des classes d’exceptions
Il existe des classes d’exceptions prédéfinies et celles créées par le programmeur.
Le programmeur crée ses propres classes d’exception en définissant des classes qui
héritent de la classe java.lang.Exception
3. Intercepter une exception
Chaque bloc catch débute par le mot clé catch, suivi de parenthèses contenant le nom
d’une classe qui spécifie le type de l’exception à capturer et un nom de paramètre.
Lorsqu’une instruction lève une exception, on quitte à ce moment le bloc try, et on se
branche sur le premier bloc catch approprié (correspondant au type d’exception), s’il en
existe un.
Exemple :
try {
int entier = Integer.parseInt(liste[i]) ; //risque d’exception
}catch (NumberFormatException e) {
System.out.println(("erreur de conversion entière " );
}
Dans le cas où une exception levée n’a été capturé par aucun bloc catch, alors
l’application se termine brutalement.

Lorsqu’on a une hiérarchie des classes d’exception, l’ordre des blocs catch doit être
présenté du type plus spécifique au type le plus général. (si non erreur de compilation)
Exemple :
class MyException extends ArithmeticException { ... }
...
void calcul () {
try { ... }
catch (Exception e) { ... } // Exception ou ArithmeticException
catch (MyException e) { ... } // erreur : Exception déjà capturée
Un catch qui intercepte un objet de la classe Exception, catch (Exception e)
capture toutes les exceptions. (Exception est la classe mère de toutes les exceptions)
Exemple :
try {
int entier = Integer.parseInt(liste[i]) ; //risque d’exception
}catch (Exception e) {
System.out.println(("Exception générale capturée " );
}
Remarque :
Un catch qui capture un objet Thowable (levable), catch (Throwable levable)
capture toutes les exceptions et toutes les erreurs. (on ne le définit pas car on ne peut
pas intercepter une erreur)
4. Lancer sa propre exception avec throw
L’instruction throw indique qu’une exception doit être lancée.
Une instruction throw spécifie un objet à lancer indiqué après l’avoir créé par new.
Exemple :
try{
if (entier < 0){
throw new MyException(); //lever une exception
}
} catch (MyException e){
System.out.println(e.getMessage());
}
L’opérande d’un throw peut être de toute classe dérivée de la classe Throwable.
Si throw n’est pas mis dans un bloc try, l’exception arrête le programme brutalement.

Une clause throws reprend une liste des exceptions qu’une méthode est susceptible de
lancer.
Syntaxe :
void Nom_ Méthode ( liste paramètres) throws MyException1, MyException2,…
{ ...
}
Exemple :
public class DivisionParZero extends ArithmeticException {
public DivisionParZero () {
super ("Tentative de division par zéro") ;
}
public DivisionParZero (String msg) {
super (msg) ;
}
}
class Division {
public int a, b;
public double res;
public Division (int nombre1, int nombre2) { // Constructeur
a = nombre1 ;
b = nombre2 ;
try{
if (b == 0){
throw new DivisionParZero();
}
else{
res = a / b ;
System.out.println("a = " + a + " b = " + b + " a/b = "+ res);
}
}catch (DivisionParZero e){
System.out.println("erreur : "+ e.getMessage());
}
}
}
// void main() est susceptible de lever une exception DivisionParZero
public static void main(String[] args) throws DivisionParZero {
Division d = new Division (12, 0); //lève une exception
}
Output : erreur : Tentative de division par zéro

Remarque :
Lorsqu’on place une instruction throw dans un bloc try{} de manière directe ou
indirecte (par appel de méthode), ou bien que la méthode qui la contient utilise un
throws, alors l’exception est levée le programme ne s’interrompt pas brutalement.
5. Propagation des exceptions
Quand une exception est levée (implicitement ou explicitement par throw) dans un bloc
try alors :
1. Les instructions qui suivent l’exception levée dans try sont ignorées
2. Les instructions du catch approprié (selon le type d’exception) sont exécutées
3. Le programme reprend normalement avec l’instruction qui suit le bloc catch
Tout appel de méthode est susceptible d’invoquer du code pouvant à son tour lancer une
exception ou appeler une autre méthode qui lève une exception.
Figure 6.2. Propagation des exceptions
étape 1
étape 2
étape 3
étape 4
étape 5
étape 6

Exemple :
6. Exercices
Exercice 1 :
public class Exercice1 {
public static void main(String args[]){
int somme = 0;
String [] tab = {"1", "2.3", "9"};
System.out.println(tab.length);
for (int i=0; i< tab.length ; i++){
somme += Integer.parseInt(tab[i]);
}
System.out.println(somme);
}
}
Le résultat d’exécution de ce programme donne le résultat suivant :
1. Expliquer pourquoi a-t-on obtenu ce résultat d’exécution ?
2. Capturer l’exception dans un bloc try … catch pour afficher un message d’erreur ?
3. Que sera alors le résultat affiché par la variable somme et pourquoi ?
4. Utiliser un throw pour lever vous-même une exception lorsqu’on arrive au deuxième
élément du tableau ? cette exception doit permettre de prendre en compte la partie entière
du deuxième élément dans le calcul de la somme.

Exercice 2 :
Soit le méthode main suivante :
public static void main (String args[]){
try {
Temps t = new Temps (25,20,30);
}catch(TempsException e){
System.out.println("erreur : " + e.message);
}
}
1. Ecrire la classe TempsException qui contient un attribut message initialisée par son
constructeur.
2. Ecrire la classe Temps qui contient 3 attributs : heure, minute et seconde. Le constructeur
de cette classe doit vérifier la validité du temps. Dans le cas d’une erreur dans l’heure, la
minute ou la seconde, une exception doit être lancée avec le message adéquat.
3. En ajoutant l’instruction suivante à la fin de void main(), on veut afficher le temps :
System.out.println(t.heure + ":" + t.minute + ":" + t.seconde);
Le compilateur détecte une erreur au niveau de l’objet t. Quels sont les deux problèmes
relatifs à l’objet t ?
4. Que se passera-t-il si on affiche le temps avec un t égal à null ? capturer l’exception levée
pour que le programme ne se plante pas.
Exercice 3 :
Soit la classe suivante :
public class Tableau {
int [] tab ;
public Tableau (){
//taille max du tableau est 3
tab = new int[3];
}
}
1. Ajouter la méthode remplirTableau (int taille) qui permet de remplir le tableau
avec un nombre de valeurs saisies au clavier. Le paramètre taille correspond au nombre de
valeurs à saisir. La méthode doit prévoir les exceptions suivantes :
- Si un nombre négatif est saisi alors une exception NegatifException est lancée.
- Si taille est égal à zéro (tableau vide) alors l’exception VideException doit être levée.
- Si la taille dépasse l’indice autorisé du tableau alors l’exception prédéfinie
ArrayIndexOutOfBoundsException est lancée.
2. Ajouter la méthode afficherTableau (int taille) qui permet d’afficher un nombre
de valeurs entré en argument. L’exception ArrayIndexOutOfBoundsException peut être
lancée par cette méthode.
3. Dans void main, créer un objet Tableau puis essayer de le remplir et de l’afficher tout en
capturant les exceptions possibles. Afficher un message d’erreur adéquat pour chaque type
d’exception. A la fin, libérer l’objet Tableau quelques soit le résultat d’appel de ses
méthodes (exceptions lancées ou non).

Chapitre 6 traitement des exceptions

Contenu connexe

Tendances

Similaire à Chapitre 6 traitement des exceptions

Plus de Amir Souissi

Dernier

Chapitre 6 traitement des exceptions