La Gestion des Exceptions

Les exceptions
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 détecter et de traiter ces erreurs ( try, catch et
finally ) et de les lever ou les propager (throw et 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é.

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

 Les exceptions
Exemple: Une exception levée à l’exécution non capturée
public class TestException {
public static void main(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 TestException.main(TestException.java: 5)
 Les exceptions
Si dans un bloc de code on fait appel à une méthode qui peut potentiellement
générer une exception, on doit soit essayer de la récupérer avec try/catch, soit
ajouter le mot clé throws dans la déclaration du bloc. Si on ne le fait pas, il y a une
erreur à la compilation ou à l’exécution. throws permet de déléguer la
responsabilité des erreurs vers la méthode appelante.

Ce procédé présente un inconvénient : de nombreuses méthodes des packages java

indiquent dans leur déclaration qu'elles peuvent lever une exception. Cependant
ceci garantie que certaines exceptions critiques seront prises explicitement en
compte par le programmeur.
 Les mots clés try,
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.
Exemple:
try {
opération_risquée ;

} catch (ExceptionInteressante e) {
traitements
} catch (ExceptionParticulière e) {
traitements
} catch (Exception e) {
traitements
} finally {
traitement_pour_terminer_proprement;
}
 Les mots clés try,
try, catch et finally
Si un événement indésirable survient dans le bloc try, la partie éventuellement non
exécutée de ce bloc est abandonnée et le premier bloc catch est traité. Si catch est défini
pour capturer l'exception issue du bloc try alors elle est traitée en exécutant le code
associé au bloc. Si le bloc catch est vide (aucune instruction entre les accolades) alors
l'exception capturée est ignorée. Une telle utilisation de l'instruction try/catch n'est pas
une bonne pratique : il est préférable de toujours apporter un traitement adapté lors de
la capture d'une exception.

S'il y a plusieurs types 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 ses sous classes ». Ainsi dans l'ordre
séquentiel des clauses catch, un type d'exception 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.
 Les mots clés try,
try, catch et finally
Exemple: erreur à la compilation car Exception est traitée en premier alors que
ArithmeticException est une sous classe de Exception
public class TestException {
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) { //traitements}
catch (ArithmeticException e) {//traitements}
}
}
Résultat:
C:\tests>javac TestException.java
TestException.java:11: catch not reached.
catch (ArithmeticException e) {
^
1 error
 Les mots clés try,
try, catch et finally
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é par un bloc catch, elle sera transmise au bloc de niveau supérieur.

L'exécution totale du bloc try et l’exécution 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. 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.
 La classe Throwable
Cette classe descend directement de la classe Object : c'est la classe de base pour
le traitement des erreurs. Elle possède deux constructeurs :
Throwable()
Throwable(String message) : la chaine qui est en paramètre permet de
définir un message qui permet de décrire l’exception et qui pourra être
consultée dans un bloc catch.

Les principales méthodes de la classe Throwable sont:

String getMessage( ): lecture du message d’erreur
void printStackTrace( ): affiche l’exception et l’état de la pile d’exécution
au moment de son appel
 La classe Throwable
Exemple:
public class TestException {
public static void main(String[] args) {
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("printStackTrace :");
e.printStackTrace();
}
}
}
 La classe Throwable
Résultat:
C:>java TestException
getmessage
/ by zero
printStackTrace
java.lang.ArithmeticException: / by zero
at TestException.main(TestException.java:8)
Les classes Exception, RunTimeException et Error
Ces trois classes descendent de Throwable : toutes les exceptions dérivent
de la classe Throwable.
Les classes Exception, RunTimeException et Error
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. Les exceptions
héritant de classe RuntimeException n'ont pas besoin d'être détectées
impérativement par des blocs try/catch.
 Les exceptions personnalisées
Pour générer une exception, il suffit d'utiliser le mot clé throw, suivi
d'un objet dont la classe dérive de Throwable. 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.

En cas de nécessité, on peut créer ses propres exceptions. Elles

descendent 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.
 Les exceptions personnalisées
Exemple:

public class SaisieErroneeException extends Exception{

public SaisieErroneeException() {
super();
}

public SaisieErroneeException(String s) {
super(s);
}
}
 Les exceptions personnalisées
public class TestSaisieErroneeException {
public static void controle(String chaine) throws
SaisieErroneeException {
if (chaine.equals("") == true)
throw new SaisieErroneeException("Saisie erronee :
chaine vide");
}

public static void main(String[] args) {

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

try {
controle(chaine2);
}
catch (SaisieErroneeException e) {
System.out.println("Chaine2 saisie erronee");
}
}
}
 Les exceptions personnalisées
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).

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 methode.

Java n'oblige la déclaration des exceptions dans l'en tête de la méthode que pour
les exceptions dites contrôlées (checked). Les exceptions non contrôlées
(unchecked) peuvent être capturées mais n'ont pas à être déclarées. Les exceptions
et erreurs qui héritent de RunTimeException et de Error sont non contrôlées.
Toutes les autres exceptions sont contrôlées.
 Utilisation des exceptions
Il est préférable d'utiliser les exceptions fournies par Java lorsque qu'une de ces
exceptions répond au besoin plutôt que de définir sa propre exception.
Il existe trois types d'exceptions :
Error : ces exceptions concernent des problèmes liés à l'environnement.
Elles héritent de la classe Error (exemple : OutOfMemoryError)
RuntimeException : ces exceptions concernent des erreurs de
programmation qui peuvent survenir à de nombreux endroits dans le code
(exemple : NullPointerException). Elles héritent de la classe
RuntimeException
Checked exception : ces exceptions doivent être traitées ou propagées.
Toutes les exceptions qui n'appartiennent pas aux catégories précédentes
sont de ce type
 Utilisation des exceptions
Les exceptions de type Error et RuntimeException sont dites unchecked exceptions
car les méthodes n'ont pas d'obligation à les traiter ou déclarer leur propagation
explicitement. Ceci se justifie par le fait que leur levée n'est pas facilement prédictible.

Il n'est pas recommandé de créer ces propres exceptions en dérivant d'une exception
de type unchecked (classe de type RuntimeException). Même si cela peut sembler
plus facile puisqu'il n'est pas obligatoire de déclarer leur propagation, cela peut
engendrer certaines difficultés, notamment :
oublier de traiter cette exception
ne pas savoir que cette exception peut être levée par une méthode.

Cependant, l'utilisation d'exceptions de type unchecked se répand de plus en plus

notamment depuis la diffusion de la plate-forme .Net qui ne propose que ce type
d'exceptions.