Chapitre 6:

Gestion des
exceptions
1
 Définition
❑Une exception est un objet qui peut être émis par une
méthode si un événement d’ordre exceptionnel (les
erreurs rentrent dans cette catégorie) se produit.
❑La méthode en question ne renvoie alors pas de valeur
de retour, mais émet une exception expliquant la cause
de cette émission.
❑Il y a 5 mots clés d’instructions dédiées à la gestion des
exceptions : try, catch, finally, throw et throws.
❑Les trois mots clés try, catch, finally permettent de
détecter et de traiter ces erreurs, et les deux autre
throw et throws permettent de les lever ou les propager.

2
 Définition
❑La gestion d’erreurs par propagation d’exception présente
deux atouts majeurs :
❖Une facilité de programmation et de lisibilité : il est possible
de regrouper la gestion d’erreurs à un même niveau. Cela
évite des redondances dans l’écriture de traitements
d’erreurs et encombre peu le reste du code avec ces
traitements.
❖Une gestion des erreurs propre et explicite : certains
langages de programmation utilisent la valeur de retour des
méthodes pour signaler une erreur à la méthode appelante.
Etant donné que ce n’est pas le rôle de la valeur de retour de
décrire une erreur, il est souvent impossible de connaître les
causes réelles de l’erreur. La dissociation de la valeur de
retour et de l’exception permet à cette dernière de décrire
précisément la ligne de code ayant provoqué l’erreur et la
nature de cette erreur. 3
 Classification des erreurs en Java
❑On peut distinguer quatre types de situations d’erreurs
en Java :
1) Erreurs de compilation : Avant même de pouvoir
exécuter le programme, notre code source génère des
erreur par le compilateur. Il faut alors réviser et corriger
le code pour ne plus avoir d’erreurs.
2) Erreurs d’exécution : Alors que notre programme est
en cours d’exécution, la JVM étant mal configurée ou
corrompue, le programme s’arrête ou se gèle. A priori,
c’est une erreur non pas due à notre programme, mais à
la configuration ou l’état de l’environnement d’exécution
de notre programme.

4
 Classification des erreurs en Java
3) Exception non vérifiée : Alors que notre programme est en
cours d’exécution, une trace de la pile des exceptions est
affichée, pointant vers une partie de notre code sans gestion
d’exception. Visiblement, nous avons utilisé du code qui est
capable de lever une exception non vérifiée (comme
NullPointerException). Il faut modifier le programme pour
que cette situation ne survienne pas
4) Exception vérifiée : Une trace de la pile des exceptions est
affichée, pointant vers une partie de notre code avec gestion
d’exception. Visiblement, nous avons produit du code qui est
capable de lever une exception vérifiée (comme
FileNotFoundException) mais les données passées à notre
programme ne valide pas ces exceptions. Il faut alors revoir
les données passées en paramètre du programme
5
 Hiérarchie des exceptions
❑Une classe est considérée comme une classe d’exception
dès lors qu’elle hérite de la classe Throwable.
❑Un grand nombre de classes d’exception sont proposées
dans l’API pour couvrir les catégories d’erreurs les plus
fréquentes.
❑Elles constituent un arbre hiérarchique utilisant la
notion d’héritage.

6
 Hiérarchie des exceptions

Erreurs non récupérable. Erreurs Erreur que l’on

fatales. Erreurs qui vont entraîner la peut traiter
fin (plantage) du programme. À ne puisque
pas gérer (inutile) récupérable.
 Les types d’Exceptions
❑ Throwable est la classe de base, à partir de laquelle vont
dériver toutes les exceptions.
❑ Error : Elle gère les erreurs liées à la machine virtuelle
(LinkageError, ThreadDeath etc.)
❑ Exception : contient l'ensemble des exceptions gérées par le
Programmeur (ArithmeticException etc.).
❑ RunTimeException : regroupe les erreurs de base (Arithmetic,
etc.)
❑ IOException : regroupe les erreurs entrée/sortie.
❑ Error et RunTimeException appartiennent à la catégorie «
uncheked » donc "throws" n'est pas nécessaire à coté de la
méthode qui lance une exception de cette catégorie là.
❑ Toutes les autres exceptions (y compris donc celles créées par le
programmeur) appartiennent à la catégorie des "checked" où
l'utilisation de "throws" est exigée.
8
 Les types d’Exceptions

❑Throwable possède 2 sous classes standard:

[Link] et [Link].
❑Les exceptions qui sont des sous classes de Error sont
généralement irrécupérables (ex: la VM n'a plus de
mémoire)
❑Les exceptions sous classes de Exception indiquent
des situations moins sévères (ex: EOFException)
signalant la fin d'un fichier ou
ArrayIndexOutOfBoundsException indiquant l'accès
en dehors des limites d'un tableau.

9
 Les types d’Exceptions

❑Checked Exceptions
Les checked exceptions sont des exceptions que le
compilateur force à gérer, c’est-à-dire que vous devez
soit les traiter avec un bloc try-catch, soit les déclarer
avec le mot-clé throws dans la signature de la méthode.
Ces exceptions représentent généralement des conditions
externes que l'application ne peut pas anticiper ou éviter,
comme des problèmes de fichiers, de réseau, ou d'accès à
une base de données.

10
 Les types d’Exceptions

❑Exemples :
❖ IOException
❖ SQLException
❖ FileNotFoundException
❑ Si une méthode est susceptible de lever une
exception "checked", vous devez utiliser throws
pour indiquer cette possibilité dans la signature de
la méthode :
public void readFile() throws IOException {
// Code qui peut lever IOException
}

11
 Les types d’Exceptions

❑Unchecked ExceptionsLes unchecked exceptions

incluent les erreurs (Errors) et les exceptions héritant
de RuntimeException. Contrairement aux checked
exceptions, elles ne sont pas forcées par le
compilateur à être gérées. Ce sont souvent des
erreurs de programmation, comme les erreurs
d'arithmétique ou d'accès à des indices de tableau
hors limites.
❑Exemples :
❖ NullPointerException
❖ ArrayIndexOutOfBoundsException
❖ ArithmeticException
12
 Exemple d’une exception de type
runtimeexception
public class ZeroDivide {
static public void main(String[] args) {
int a = 3;
int b = 0;
[Link]("Resultat de la division : "+a/b);
}
}
❑ Ce code se compile mais une exception apparaît au
niveau de l’exécution et le programme s’arrête.
❖ Une ArithmeticException est une RuntimeException.
❑ Les RuntimeException ne sont pas vérifiées par le
compilateur
Interception et traitement des exceptions

❑L’interception d’exceptions se fait par une sorte de

"mise sur écoute" d’une portion de code. Pour cela
on utilise le mot-clé try suivi du bloc à surveiller.
❖Si aucune exception ne se produit dans le bloc
correspondant, le programme se déroule
normalement comme si l’instruction try était
absente.
❖Par contre, si une exception est levée, le traitement de
l’exception est exécuté puis l’exécution du
programme reprend son cours après le bloc testé.

14
Interception et traitement des exceptions

❑Il est également nécessaire de préciser quelles classes

d’exception doivent être interceptées dans le bloc
testé.
❑L’interception d’une classe d’exception s’écrit grâce
au mot-clé catch suivi de la classe concerné, d’un
nom de variable correspondant à l’objet exception,
puis du traitement.
❑La clause finally définit un bloc qui sera toujours
exécuté, qu’une exception soit levée ou non. Ce bloc
est facultatif. Il est aussi exécuté si dans le bloc try il
y a une instruction break ou continue.

15
Interception et traitement des exceptions
❑ Le principe de capture d’exception permet de ne pas
interrompre l’exécution du programme.
❑ Interception par bloc try - catch - finally
try {
// quelques actions potentiellement risquées
}
catch ( SomeException se) {
// que faire si une exception de ce type survient
}
catch ( Exception e) {
// que faire si une exception d’un autre type survient
}
finally {
// toujours faire ceci , quelle que soit l’exception
}

16
Interception et traitement des exceptions
❑ Exemple : Division par zéro
public class ExcepExemple1 {
public static void main ( String [] args ) {
int i=4;
int j =0;
int x;
x = i/j;
System . out. println ("x = "+x);
System . out. println (" Fin programme ");
}
}
❑ Si on exécute le programme, un message d’erreur s’affiche :
Exception in thread " main " java . lang . ArithmeticException :
/ by zero
at ExcepExemple1 . main ( ExcepExemple1 . java :8) Java Result
:1
17
Interception et traitement des exceptions
❑ Exemple : Traitement des exceptions
Division par zero
public class ExcepExemple {
Message System :
public static void main ( String [] args ) {
/ by zero
int i=4; int j =0; int x;
Fin programme
try{
x= i/j; // L’ instruction qui cr´ee l’exception
[Link]("x = "+x);
}
// Appel du gestionnaire d’exception Exception
catch ( Exception err ){
System . out. println (" Division par zéro");
System . out. println (" Message System : " + err.
getMessage ());
}
System . out. println (" Fin programme ");
}
} 18
 Déclaration des exceptions
❑ Il est nécessaire de déclarer, pour chaque méthode, les classes
d’exception qu’elle est susceptible d’émettre
❑ Cette déclaration se fait à la fin de la signature d’une méthode
par le mot-clé throws, à la suite duquel les classes d’exceptions
(séparées par une virgule s’il en existe plusieurs) qui peuvent
être générées sont précisées
❑ throws permet de signaler à la JVM qu’un morceau de code,
une méthode, une classe... est potentiellement dangereux et
qu’il faut utiliser un bloc try...catch...
❑ Il est suivi du nom de la classe qui va gérer l’exception
❑ Une méthode avec une propriété throws peut 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 !!

19
 Déclaration des exceptions
❑ Exemple : Utilisation de throws et throw
public class ExcepExemple {
public static double division ( double i, double j)
throws Exception /* On doit citer le type d’exception à
créer */ {
double x;
if (j ==0){
/* Création manuelle d’une exception par une
méthode */
throw new Exception (" Division par 0");
}
x=i/j;
return x;
} 20
 Déclaration des exceptions
❑ Exemple : Utilisation de throws et throw
public static void main ( String [] args ) {
try {
double y = division (1 ,0);
System . out . println ("y= "+y);
}
catch ( Exception erreur ){
[Link](" Message : "+ erreur.
getMessage ());
}
[Link](" Fin programme ");
}
}
21
 Déclaration des exceptions

❑ Exemple : Utilisation de throws et throw

❖ L’exécution du programme, nous affiche :
Message : Division par 0
Fin programme

22
 Déclaration des exceptions
Nouvelles classes d’exceptions
❑ En cas de nécessité, on peut créer de nouvelles classes
d’exceptions et les lancer avec throw
❑ Elles descendent des classes Exception ou RunTimeException
mais pas de la classe Error
class MyException extends Exception{
public MyException ( String msg ){
[Link] ("MyException lancee , msg =" + msg );
}
}
void someMethod ( boolean flag ) throws MyException{
if (! flag )
throw new MyException ("no flag ");
...
}
23
 Le choix entre throws et catch

❑ Si on appelle une méthode qui lève une exception non

runtime, on utilise :
❖ catch si l’on peut reprendre sur l’erreur et faire
quelque chose de cohérent (appliquer une action
corrective).
❖ Sinon throws pour propager l’exception vers celui qui
a appelé la méthode qui fera ce qu’il doit faire.

24
 Exemple applicatif des exceptions

❑ Exemple 1 : Création de nos propos Gestionnaires d’Exception

Creation des classes :
❖ Point
❖ ConstructException
❖ DeplaceException

25
 Exemple applicatif des exceptions
/** ************* class ConsException **************** */
class ConstructException extends Exception {
public ConstructException ( String s){
super (s);
}
}
/** ************* class DepException **************** */
class DeplaceException extends Exception {
public DeplaceException ( String s){
super (s);
}
}

26
 Exemple applicatif des exceptions
public class Point {
private int x;
private int y;
public Point ( int x, int y) throws ConstructException {
if (x <0 || y <0)
throw new ConstructException (" Erreur de Construction ");
this .x = x;
this .y = y;
}
public void deplacer ( int dx , int dy) throws DeplaceException{
if ((x+dx )<0 || (x+dy ) <0)
throw new DeplaceException (" Erreur de déplacement ");
this .x = this .x + dx;
this .y = this .y + dy;
}
}
27
 Exemple applicatif des exceptions
/** **************** class ExcepExemple2 *************** */
public class ExcepExemple2 {
public static void main ( String [] args ) { l’exécution du
try { programme, nous
Point p1 = new Point (1 ,2); affiche :
p1. deplacer (1, 1); p1. deplacer (-5, -4); Erreur de déplacement
Fin du programme
Point p2 = new Point (1 ,3);
}
catch ( ConstructException e){
[Link] (e. getMessage ());
}
catch ( DeplaceException e){
[Link] ([Link] ());
}
[Link] (" Fin du programme ");
}
} 28
 Exemple applicatif des exceptions

❑ Exemple 1 : Utilisation du mot clé finally

Utilisation des classes
❖ Point
❖ ConstructException
❖ DeplaceException

29
 Exemple applicatif des exceptions
public class ExcepExemple2 {
public static void main ( String [] args ) {
try {
Point p1 = new Point (1 ,2);p1. deplacer (1, 1);
p1. deplacer (5, 4);Point p2 = new Point (1 ,3);
}
catch ( ConstructException e){ l’exécution du
[Link] (e. getMessage ()); programme, nous
} affiche :
La partie Finally
catch ( DeplaceException e){ Fin du programme
[Link] ([Link] ());
}
finally {
[Link] ("La partie Finally " );
}
System . out . println (" Fin du programme ");
}} 30
 Exercice : Gestion d'accès à un tableau
Écrire un programme Java qui demande à l'utilisateur de saisir un
index pour accéder à un élément d'un tableau prédéfini. Le
programme doit gérer les exceptions suivantes :
❑ ArrayIndexOutOfBoundsException : Si l'utilisateur saisit un
index qui dépasse les limites du tableau.
❑ InputMismatchException : Si l'utilisateur entre autre chose
qu'un nombre entier pour l'index.
❑ Étapes :
❖ Créez un tableau d'entiers avec quelques éléments prédéfinis.
❖ Demandez à l'utilisateur de saisir un index pour accéder à
l'élément du tableau.
❖ Gérer les exceptions mentionnées.

31
 Exercice : Gestion d'accès à un tableau
import [Link];
import [Link];
public class TableauAcces {
public static void main(String[] args) {
int[] tableau = {10, 20, 30, 40, 50};
Scanner scanner = new Scanner([Link]);
try {
[Link]("Saisissez un index pour accéder à l'élément
du tableau : ");
int index = [Link]();
[Link]("L'élément à l'index " + index + " est : "
+ tableau[index]);
}
catch (ArrayIndexOutOfBoundsException e) {
[Link]("Erreur : L'index est hors des limites du
tableau.");
} 32
 Exercice : Gestion d'accès à un tableau
catch (InputMismatchException e) {
[Link]("Erreur : Veuillez entrer un nombre
entier.");
}
finally {
[Link]("Fin du programme.");
}
}
}

33