CHAPITRE 1 : LES EXCEPTIONS
I- Introduction
Lorsqu’un programme rencontre une anomalie, comme une division par zéro, ou un
avertissement de mémoire insuffisante, une exception est générée (ou levée).
Si aucun gestionnaire d'exceptions pour cette exception n'est présent, le programme cesse de
s'exécuter.
Le mécanisme d'exception de Java permet de :
· Capturer les exceptions et de proposer un traitement à l'exception capturée.
· Propager l'exception à la méthode appelante où l'exception sera traitée.
· Créer ses propres exceptions.
II- Traiter les exceptions avec Java
Le principe consiste à repérer un morceau de code qui pourrait générer une exception (une
division par zéro, par exemple), de capturer l'exception correspondante, et enfin de gérer
celle-ci, c'est-à-dire d'afficher un message personnalisé et de continuer le traitement.
try
{
// lignes de code à protéger
}
catch (<TypeException> e)
{
// lignes de code réagissant à l’exception de Type <TypeException>
}
finally
{
// Code s'exécute après l'exécution des blocs try et catch (code exécuté qu’une exception
est levée ou pas)
}
Bloc Catch
Un bloc catch peut spécifier un type d'exception à intercepter. La classe <TypeException> est
obligatoirement une classe qui hérite de la classe Throwable.
Bloc finally
Le bloc finally est facultatif, il permet de libérer les ressources telles que flux fichier et
connexions de bases de données. Il est exécuté dans tous les cas.
1
Objets d’exceptions
En Java, toute erreur lors d'une instruction génère un OBJET exception. Cet objet est une
instance d'une classe qui hérite de la classe Throwable.
ci-dessous un extrait de la hiérarchie de classes d'exceptions :
La classe Throwable possède deux sous-classes: Error et Exception.
- On ne traite pas les instances de la classe Error, ce sont des erreurs rares que seul Java
pourra exploiter.
- Par contre, vous pouvez traiter les instances de la classe Exception.
Dans cette classe on retrouve des exceptions particulières: les RuntimeException (ces
exceptions interviennent lors de l'exécution du programme pour différentes raisons: mauvais
index de tableau, division par zéro ...).
Exemple de classes d’exception prédéfinies dans java :
2
- Division par zéro pour les entiers : ArithmeticException
- Référence nulle : NullPointerException
- Tentative de forçage de type illégale : ClassCastException
- Tentative de création d'un tableau de taille négative :
NegativeArraySizeException
- Dépassement de limite d'un tableau : ArrayIndexOutOfBoundsException
Quelques méthodes de la classe Throwable :
La méthode getMessage() retourne le message de l’exception
La méthode printStackTrace() affiche, la liste des appels ayant conduit à la génération
de l'exception.
Exemple
try
{
[Link]("Resultat de la division : " + a/b);
[Link]("Instructions suivant la division...");
}
catch(ArithmeticException e)
{
[Link]("Une exception s'est produite ! (ArithmeticException)");
}
finally
{
[Link]("Bloc Finally\n");
}
[Link]("Instructions qui suivent le bloc finally...");
Résultat: si b=0
Une exception s'est produite ! (ArithmeticException)
Bloc Finally
Instructions qui suivent le bloc finally...
Exemple 2 :
try{
for( int i = 0; ; ++i) [Link](t[i]);
}catch( IndexOutOfBoundsException iobe){
// traitement de l’exception
}
Blocs Catch enchaînés
Plusieurs blocs catch avec des types d'exception différents peuvent être enchaînés.
try { < bloc de code à protéger> }
catch ( TypeException1 e ) { <Traitement TypeException1 > }
catch ( TypeException2 e ) { <Traitement TypeException2 > }
catch ( TypeExceptionk e ) { <Traitement TypeExceptionk > }
3
Où TypeException1, TypeException12, ... , TypeExceptionk sont des classes d'exceptions
obligatoirement toutes distinctes.
- Seule une seule clause catch ( TypeException E ) {...}est exécutée (celle qui
correspond au bon type de l'objet d'exception instancié).
- Lorsqu’il y a une hiérarchie entre les exceptions à intercepter, de placer le code de
leurs clauses dans l’ordre inverse de la hiérarchie.
Exemple :
int[] T=new int[4];
int i=10;
int j=0;
try {
int x=i/j;
T[5]=x;
}
catch (ArithmeticException e) {
[Link]("Division par zero " + [Link]());
}
catch (ArrayIndexOutOfBoundsException e) {
[Link]("Index hors intervalle : doit être < 4" + [Link]());
}
III. Propager l’exception
Lorsque les méthodes utilisées génèrent des exceptions on doit traiter ces exceptions.
Parfois il n'est pas possible ou pas souhaité de traiter l'exception immédiatement. Dans ce cas
on doit déclarer celle-ci en utilisant le mot-clé throws dans l'en-tête de la méthode susceptible
de générer l'exception en question. On propage alors l'exception à la méthode appelante, c'est
à dire à la méthode qui fait appel à la méthode à partir de laquelle l'exception est générée.
C'est-à-dire que si une méthode est susceptible de lever une exception qu’on ne veut pas
gérer au sein de la méthode, elle se doit de prévenir les appelants avec le mot clé throws.
Exemple:
void uneMethode (int a) throws IOException {
...
}
Au niveau de la méthode appelante :
//Instructions
try
{
uneMethode(10) ;
4
}
Catch (IOException e)
{
[Link]("Une exception s'est produite !");
}
IV. Personnaliser une exception
Il est possible de créer dans les applications vos propres classes d'exception. La nouvelle
classe d'exception créée doit obligatoirement hériter de la classe Exception de Java ou d'une
de ses sous-classes plus spécifiques.
La structure de la nouvelle classe d'exception doit au moins posséder un des deux
constructeurs:
· un sans paramètre
· un avec un paramètre de type String correspondant au message associé à l'erreur
générée.
Exemple de déclaration d'une nouvelle classe d'exception
class MaClasseException extends Exception{
MaClasseException(){
super();
}
MaClasseException(String monMessage){
super(monMessage);
}
Les méthodes de la classe Exception seront également disponibles pour votre nouvelle classe.
Vous pourrez donc:
afficher la valeur du message éventuellement transmis en paramètre au constructeur
de la classe grâce à la méthode getMessage()
afficher, sur la sortie d'erreur, la liste des appels ayant conduit à la génération de
l'exception grâce à la méthode printStackTrace()
Pour déclencher une exception, on utilise le mot clé throw. Il permet de lancer une exception
en instanciant un objet sur une classe dérivée de la classe Exception.
throw new MaClasseException ("Erreur générée");
Exemple d'implémentation d'une méthode qui génère une exception
public void maMethode throws MaClasseException {
if (condition_particuliere)
throw new MaClasseException("Message d'erreur");
}
5
Exemple :
1. Nous devons créer une classe héritée de la classe Exception :
Exemple :
public class NombreHabitantsException extends Exception {
public NombreHabitantsException(String s)
{super("Vous essayez d'instancier une Ville avec un nombre d'habitants négatif !") ; }
}
2. Nous devons renvoyer l'exception levée à notre classe d’exception
Exemple : NombreHabitantException.
public Ville(int nombreHabitants) throws NombreHabitantsException
if (nombreHabitants<0)
throw new NombreHabitantsException();
else
[Link]=nombreHabitants;
Pour capturer l’exception susceptible de lever une exception de type
NombreHabitantsException on écrit
try {
Ville v=new Ville(- 500);
}
catch (NombreHabitantsException e) {
[Link]([Link]());
}
