M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

La gestion des exceptions en Java

Les exceptions représentent le mécanisme de gestion des erreurs intégré au

langage java. Il se compose d'objets représentant les erreurs et d'un ensemble de
trois mots clés qui permettent :

- de capturer et de traiter ces erreurs : try, catch et finally

- de lever les exceptions : throw
- de les propager throws.

Lors de la détection d'une erreur, un objet qui hérite de la classe Exception est créé
(on dit qu'une exception est levée) et propagé à travers la pile d'exécution jusqu'à ce
qu'il soit traitée.

Ces mécanismes permettent de renforcer la sécurité du code java.

Exemple 1 : une exception levée à l'exécution non capturée

public class TestException {

public static void main(java.lang.String[] args) {
int i = 3;
int j = 0;
System.out.println("résultat = " + (i / j));
}
}

Résultat :

C:>java TestException
Exception in thread "main" java.lang.ArithmeticException: /
by zero
at tests.TestException.main(TestException.java:23)

Dans cet exemple une erreur se produit dans le code Java, division par zéro. Il n’y a
pas de d’instruction qui gère cette erreur, c’est donc le gestionnaire d’exception par
défaut Java qui gère l’erreur, avec un message et l’interruption de l’exécution.

Page : 1
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

Si dans un bloc de code on fait appel à une méthode qui peut potentiellement
générer une exception, on doit essayer de :

- soit la capturer avec les blocs try/catch,

- soit la lever avec le mot clé throw
- soit la propager avec le mot clé throws dans la déclaration du bloc.

Si on ne le fait pas, il y a une erreur à la compilation. Les erreurs et exceptions du

paquetage java.lang échappent à cette contrainte. Throws permet de déléguer la
responsabilité des erreurs vers la méthode appelante.

1-CAPTURER UNE EXCEPTION

Les mots clés java utilisés :

try, catch et finally

Le bloc try rassemble les appels de méthodes susceptibles de produire des erreurs
ou des exceptions. L'instruction try est suivie d'instructions entre des accolades.
Le(s) bloc(s) catch gére(nt) les erreurs ou exceptions et le bloc finally termine le
traitement

Exemple :
try {
// Code sensible;
}
catch (ExceptionType1 e) {
// Gestion de l’exception de type 1
}
catch (ExceptionType2 e) {
// Gestion de l’exception de type 1
}
catch (Exception e) {
// Gestion de l’exception standard
}
finally {
Code à exécuter avant de terminer le bloc try
}

Lorsqu’une partie de code sensible d’un bloc try lève une exception, cette dernière
peut-être capturée par un bloc catch. Il est aussi possible d‘ajouter un bloc finally
qui exécute du code une fois le bloc try/catch achevé. Le code du bloc finally est
toujours exécuté, qu’une exception se soit produite ou non.

Page : 2
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

Si il y a plusieurs type d'erreurs et d'exceptions à intercepter, il faut définir autant de

bloc catch que de type d'événement. Par type d'exception, il faut comprendre « qui
est du type de la classe de l'exception ou d'une de ces sous classes ». Ainsi dans
l'ordre séquentiel des clauses catch, un type d'exception de ne doit pas venir après
un type d'une exception d'une super classe. Il faut faire attention à l'ordre des
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.

Exemple 2 : erreur à la compil car Exception est traité en premier alors que
ArithmeticException est une sous classe de Exception
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (Exception e) {
}
catch (ArithmeticException e) {
}
}
}

Résultat :
C:\tests>javac TestException.java
TestException.java:11: catch not reached.
catch (ArithmeticException e) {
^
1 error

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é. Si l'exception n'est pas
traitée par un bloc catch, elle sera transmise au bloc de niveau supérieur. Si l'on ne
se trouve pas dans un autre bloc try, on quitte la méthode en cours, qui re-génère à
son tour une exception dans la méthode appelante.

L'exécution totale du bloc try et d'un bloc d'une clause catch sont mutuellement
exclusives : si une exception est levée, l'exécution du bloc try est arrêtée et si elle
existe, la clause catch adéquate est exécutée.

Page : 3
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

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.

Les blocs try peuvent être imbriqués dans d’autres blocs try. Si un bloc try ne
possède pas de bloc catch correspondant pour gérer une exception, java recherche
dans le bloc try de niveau supérieur un bloc catch pouvant gérer l’exception. Le
processus se répète dans les niveaux successifs. Si aucun bloc catch ne correspond
à l’exception, Java le transfère au gestionnaire d’exception par défaut.

Exemple 3: blocs try imbriqués

public class TestException {
public static void main(java.lang.String[] args) {

try {
try {
ind tab[ ] = { 0, 1 ,2 ,3};
tab[4] = 4;
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Indice de tableau hors bornes : " + e);
}
}
catch (ArithmeticException e) {
System.out.println("Division par zero : " + e);
}
}
}

Résultat :
C:\tests>java TestException.java
Indice de tableau hors bornes : java.lang.ArrayIndexOutOfBoundsException: 4

Page : 4
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

2 – LEVER UNE EXCEPTION

Pour lever une exception, il suffit d'utiliser le mot clé throw, suivi d'un objet dont la
classe dérive de Throwable ou Exception. Si l'on veut générer une exception dans
une méthode avec throw, il faut l'indiquer dans la déclaration de la méthode, en
utilisant le mot clé throws.

Exemple 4 : Exception levée sans capture

public class TestException {
public static void main(java.lang.String[] args) {

controle();
System.out.println("Suite du traitement ");
}
static void controle() throws ArithmeticException {
throw new ArithmeticException ("Exception !");

}
}

Résultat :
java.lang.ArithmeticException: Exception !
at testexception.Ex4.controle(Ex4.java:19)
at testexception.Ex4.main(Ex4.java:15)
Exception in thread "main"

Exemple 5 : Exception levée avec capture dans méthode

public class TestException {
public static void main(java.lang.String[] args) {
controle();
System.out.println("Suite du traitement ");
}
static void controle() throws ArithmeticException{
try {
throw new ArithmeticException ("Exception !");
}
catch (ArithmeticException e) {
System.out.println("Capturée dans controle " + e);
}
}
}

Page : 5
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

Résultat :
Capturée dans controle java.lang.ArithmeticException: Exception !
Suite du traitement

Exemple 6 : Exception levée avec capture dans le main (appelant)

public class TestException {
public static void main(java.lang.String[] args) {

try {
controle();
}
catch (ArithmeticException e) {
System.out.println("Capturée dans main " + e);
}
finally {
System.out.println("Suite du traitement ");
}
}
static void controle() throws ArithmeticException {
throw new ArithmeticException ("Exception !");
}
}

Résultat :
Capturée dans main java.lang.ArithmeticException: Exception !
Suite du traitement

Page : 6
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

LA CLASSE THROWABLE

Cette classe descend directement de Object : c'est la classe de base pour le

traitements des erreurs.

Cette classe possède deux constructeurs :

Méthode Rôle
Throwable() Constructeur, crée un objet Throwable
La chaîne en paramètre permet de définir un
Throwable(String message) message qui décrit l'exception et qui pourra être
consultée dans un bloc catch.

Les principales méthodes de la classe Throwable sont :

Méthodes
String toString()
String getMessage( )
void printStackTrace( )
void
printStackTrace(PrintStream s)
Rôle
Renvoie une courte description de cet objet
Throwable
Renvoie le texte du message d’erreur de cet objet
Throwable
affiche l'exception et l'état de la pile d'exécution au
moment de son appel
Idem mais envoie le résultat dans un flux

Exemple :
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("getmessage");
System.out.println(e.getMessage());
System.out.println(" ");
System.out.println("toString");
System.out.println(e.toString());
System.out.println(" ");

Page : 7
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

System.out.println("printStackTrace");
e.printStackTrace();
}
}
}

Résultat :
C:>java TestException
getmessage
/ by zero

toString
java.lang.ArithmeticException: / by zero

printStackTrace
java.lang.ArithmeticException: / by zero
at tests.TestException.main(TestException.java:24)

Les classes Exception, RunTimeException et Error

Ces trois classes descendent de Throwable : en fait, toutes les exceptions dérivent
de la classe Throwable.

La classe Error représente une erreur grave intervenue dans la machine virtuelle
Java ou dans un sous système Java. L'application Java s'arrête instantanément dès
l'apparition d'une exception de la classe Error.

La classe Exception représente des erreurs moins graves. La classe

RuntimeException n'ont pas besoin d'être détectées impérativement par des blocs
try/catch

Page : 8
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

LES EXCEPTIONS PERSONNALISEES

En cas de nécessité, on peut créer ces propres exceptions. Elles héritent des classes
Exception ou RunTimeException mais pas de la classe Error. Il est préférable (par
convention) d'inclure le mot « Exception » dans le nom de la nouvelle classe.

Exemple :
public class SaisieErroneeException extends Exception {
public SaisieErroneeException() {

}
public SaisieErroneeException(String s) {
System.out.println (s);
}
}

public class TestSaisieErroneeException {

public static void controle(String chaine) throws SaisieErroneeException {

if (chaine.equals("") == true)
throw new SaisieErroneeException("Saisie erronée : chaine vide");
}

public static void main(java.lang.String[] args) {

String chaine1 = "bonjour";
String chaine2 = "";
try {
controle(chaine1);
}
catch (SaisieErroneeException e) {
System.out.println("Chaine1 saisie erronee");
};
try {
controle(chaine2);
}
catch (SaisieErroneeException e) {
System.out.println("Chaine2 saisie erronée");
};
}
}

Les méthodes pouvant lever des exceptions doivent inclure une clause throws
nom_exception dans leur en tête. L'objectif est double : avoir une valeur
documentaire et préciser au compilateur que cette méthode pourra lever cette
exception et que toute méthode qui l'appelle devra prendre en compte cette
exception (traitement ou propagation).

Page : 9
 M3 ALGORITHMIQUE ET PROGRAMMATION PROCEDURALE GestionException

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 déclared in the thows
clause of this méthode.

Java Fournit de nombreuses classes prédéfinies dérivées de la classe Exception, qui

sont utilsées par certaines méthodes standard ; par exemple, la classe
IOException et ses dérivées sont utilisées par les méthodes d’entrée-sortie.
Certaines classes exception sont même utilisées par la machine virtuelle à la
rencontre de situations anormales telles q’un indice de tableau hors limites, une taille
de tableau négative…

Ces exceptions standard se classent en deux catégories :

- les exceptions explicites (on dit aussi sous contrôle ou checked)). Elles
doivent être traitées par une méthode, ou bien mentionnées dans la
clause throws.
- Les exceptions implicites (ou hors contrôle ou unchecked) n’ont pas être
mentionnées dans une clause throw et on n’est pas obligé de les traiter.

Les exceptions et erreurs qui héritent de RunTimeException et Error sont non

contrôlées. Toutes les autres exceptions sont contrôlées.

En fait, cette classification sépare les exceptions susceptibles de se produire

n’importe où dans le code et celles dont on peut distinguer les sources potentielles.
Par exemple, un débordement d’indice ou une division par zéro peuvent se produire
presque partout dans un programme ; ce n’est pas le cas d’une erreur de lecture, qui
peut survenir que si l’on fait appel à des méthodes bien précises.

Page : 10