Gérer les Exceptions
1. Qu'est ce qu'une exception ?
2. Pourquoi gérer ses erreurs à l'aide des exceptions ?
3. Dans quel cas utiliser la gestion d'exception ?
4. Modèle à suivre pour gérer une exception
5. Les blocs try , catch et finally
6. Comment obtenir un message approprié à chaque type d'Exception ?
7. Renvoyer une exception à la méthode précédente
8. Comment lever une exception ?
1. Qu'est ce qu'une exception ?
Une exception est un objet créé lorsqu'une situation anormale se produit pendant l'exécution de votre programme. Les exceptions sont toujours issues de la classe Throwable.
2. Pourquoi gérer ses erreurs à l'aide des exceptions ?
Il est fortement conseillé de toujours séparer la gestion des erreurs du code " normal " de son application.
Les exceptions sont donc un moyen simple et propre de les dissocier.
3. Dans quel cas utiliser la gestion d'exception ?
Chaque fois que vous avez un code susceptible de " lever " une exception, vous devez la prévoir et la gérer.
Voyons le code suivant :
public static void main(String[] args) {
int tab[] = new int[10];
for(int i=0;i<12;i++)
tab[i] = i;
}
On peut voir ici que ce code risque de lever une exception de type ArrayIndexOutOfBoundsException puisque l'on dépasse la taille du tableau.
Effectivement, en exécutant le programme on obtient le résultat suivant :
java.lang.ArrayIndexOutOfBoundsException: 10
at TestLocale.main(TestLocale.java:17)
Exception in thread "main"
Nous verrons un peu plus bas comment gérer cette exception.
Le site suivant classe toutes les exceptions par package:
http://www.falkhausen.de/en/diagram/diagram.html
4. Modèle à suivre pour gérer une exception
try{
//code risquant de déclencher une exception
}
catch(Exception1 e){
//code décrivant ce qui doit être fait lorsqu'une exception de
// type Exception1 a été déclenchée.
}
catch(Exception2 e){
//code décrivant ce qui doit être fait lorsqu'une exception de
// type Exception2 a été déclenchée.
}
finally{
//code à exécuter dans tous les cas, que l'exception ait été
//déclenchée ou non
}
5. Les blocs try , catch et finally
En général, on encapsule seulement le code susceptible de déclencher une exception dans le try{ }.
Le code écrit dans le block catch{ }, n'est exécuté que lorsque qu'une exception a été déclenchée tandis que le code écrit dans le bloc finally{ } sera exécuté en toute circonstance.
Pour gérer une exception, le bloc try{ } est obligatoire mais la présence simultanée des deux blocs catch{ } et finally{ } n'est pas requise, en effet, seul l'un ou l'autre suffit.
Un bloc catch{ } ou finally{ } doit toujours être précédé d'un bloc try{ }.
Plusieurs blocs catch{ } peuvent se suivre. Cela permet en effet de définir une action différente pour chaque type d'exception que l'on souhaite gérer.
Il est conseillé de hiérarchiser les blocs catch de l'exception la plus particulière à la plus générale.
Exemple :
On souhaite prévoir le cas ou la taille d'un tableau de taille 10 est dépassée. Il s'agit d'une Exception du type ArrayIndexOutOfBoundsException qui est issue de l'Exception IndexOutOfBoundsException, elle même issue de la classe RuntimeException.
int tab[] = new int[10];
try{
for(int i=0;i<12;i++)
tab[i] = i;
}
catch(ArrayIndexOutOfBoundsException ae)
{
System.out.println("ArrayIndexOutOfBoundsException");
}
catch(IndexOutOfBoundsException ie)
{
System.out.println("IndexOutOfBoundsException");
}
catch(RuntimeException re)
{
System.out.println("RuntimeException");
}
Affichage :
ArrayIndexOutOfBoundsException
6. Comment obtenir un message approprié à chaque type d'Exception?
La classe Exception (et donc toutes ses classes filles) possède plusieurs méthodes permettant d'obtenir un message spécifique à l'exception.
En voici quelques une :
fillInStackTrace() // renvoie une chaîne de caractères ;le nom de l'exception ainsi que ce qui l'a déclanchée
printStackTrace() // renvoie la trace de la pile au flux de sortie standard
getMessage() // renvoie une chaîne de caractères ; décrit ce qui a causé l'exception déclanchée
Voyons un exemple d'utilisation de ces méthodes:
int tab[] = new int[10];
try{
for(int i=0;i<12;i++)
tab[i] = i;
}
catch(ArrayIndexOutOfBoundsException ae)
{
System.out.println("-le fillInStackTrace, "+ae.fillInStackTrace());
System.out.println("-le getMessage, "+ae.getMessage());
ae.printStackTrace();
}
Affichage :
-le fillInStackTrace, java.lang.ArrayIndexOutOfBoundsException: 10
-le getMessage, 10
java.lang.ArrayIndexOutOfBoundsException: 10
at divers.Divers.main(Divers.java:33)
Le choix d'utilisation de l'une ou l'autre de ses méthodes dépend des besoins du programmeur. En effet, dans le cas présent la méthode fillInStackTrace() ou getMessage() aurait suffit.
Nous verrons plus tard dans quel cas la méthode printStackTrace() est très utile.
7. Renvoyer une exception à la méthode précédente
Si vous ne souhaitez pas gérer une exception dans la méthode qui la contient et par exemple gérer toutes les exceptions dans le main, vous pouvez renvoyer la gestion de vos exception à la méthode précédente à l'aide de la syntaxe suivante ;
public void nomMethode () throws Exception1{
//Code
}
La méthode nomMethode() va contenir le code risquant de générer l'exception de type Exception1. Le throws Exception1 va récupérer l'exception générée et la renvoyer à la méthode appelant nomMethode(). C'est alors dans cette méthode que l'on va gérer.
Exemple :
public static void main(String[] args) {
try {
System.out.println(message());
} catch (ArrayIndexOutOfBoundsException ae) {
System.out.print("La pile : ");ae.printStackTrace();
}
}
public static String message()throws ArrayIndexOutOfBoundsException{
remplir();
return("Remplissage de tableau");
}
public static void remplir() throws ArrayIndexOutOfBoundsException{
int[] i = new int[10];
for(int e = 0; e <= 10; e++)
i[e] = e;
}
Affichage :
La pile : java.lang.ArrayIndexOutOfBoundsException: 10
at divers.Divers.remplir(Divers.java:37)
at divers.Divers.message(Divers.java:30)
at divers.Divers.main(Divers.java:23)
L'exception s'est donc produite dans la méthode remplir() mais a été gérée dans le main().
On voit bien ici que la méthode printStackTrace() est très utile et appropriée à la situation puisqu'elle permet de retracer l'origine de l'exception.
8. Comment lever une exception ?
Le mot clé throw signale qu'une erreur s'est produite et lève une exception. Ceci entraîne l'arrêt du déroulement du programme et effectue un saut inconditionnel sur l'instruction catch la plus proche qui va capturer l'exception.
Pour cela, il suffit de créer une instance de la classe Exception puis lever cette exception à l'aide de throw .
Exemple :
public static void main(String[] args) {
int a, b = 12, c = 0;
try {
if (c == 0)
throw new ArithmeticException("division par zéro impossible");
else
a = b / c;
} catch (ArithmeticException e) {
System.out.println(e.fillInStackTrace());
}
}
Affichage :
java.lang.ArithmeticException: division par zéro impossible
Vous connaissez maintenant l'essentiel de ce qu'il faut savoir sur les exceptions,bon courage !
Voir le cours complet sur les Exceptions.
| 
