Rechercher
 

La gestion des exceptions

Les niveaux d'accès La généricité



Nous allons au cours de ce chapitre nous intéresser à la gestion et à la manipulation des exceptions. Celles-ci permette de traiter, d'une façon plus élégante les cas d'erreurs que ce que l'on aurait pu trouver en C, par exemple, pour réaliser les même choses.

Comme nous allons le voir, deux mécanismes principaux permettent d'acquitter une exception. Soit on la traite, soit on la relaye à la méthode appelante. Pour mieux comprendre les choses, rentrons de suite dans des exemples clairs et explicites.

On traite l'exception.

Si l'on décide de traiter une exception, il nous faut alors définir un certain nombre de blocs d'instructions. Pour ce faire, trois mots clés sont à notre disposition : try, catch, finally. Nous allons donc étudier chacun de ces mot clés en détail.

Le mot clé try.

Ce mot clé permet de spécifier une section de code sur laquelle on s'attend qu'une exception (une erreur) soit levée. La syntaxe est simple on place le mot try, une accolade ouvrante, la section de code et, enfin, une accolade fermante.

Le mot clé catch.

Celui-ci, sert à spécifier le code à exécuter pour une exception (ou une catégorie) donnée. Il suffit alors de faire suivre le mot catch d'une parenthèse ouvrante, d'un type exception (une classe) du nom qu'on lui donne (tout comme un paramètre de fonction), d'une parenthèse fermante, et du code associé placé entre accolade.

Le mot clé finally.

Enfin, le mot clé finally permet d'introduire un code de traitement d'exception, qui sera de toute manière exécuté. Vous pouvez omettre le bloc finally.

 
try {
    // des lignes de code susceptible
    // de lever une exception
}
catch (IOException e) {
    // traitement de l'exception de type IO
}
finally {
    // traitement plus général
}

Quelques exceptions.

Le tableau suivant vous propose quelques exemples d'exceptions que vous pouvez traiter.

Exception
IOException
NullPointerException
OutOfMemoryException
ArithmeticException
ClassCastException
ArrayIndexOutOfBoundsException
negativeArraySizeException

Quelques méthodes utilisables sur les exceptions.

Le tableau suivant vous propose quelques méthodes applicables sur des objets dérivés de la classe Exception.

String toString()
void printStackTrace()

On relaye l'exception.

Maintenant, le problème est de savoir ce que l'on doit faire d'une exception que l'on aurait pas su traiter. Dans ce cas, il faut alors la relayer à la méthode appelante. Plus généralement, si une méthode est susceptible de lever une exception, et si celle-ci ne peut la traiter, elle se doit de prévenir le système qu'elle relaye cette tâche. Pour ce faire on utilise le mot clé throws.

Le mot clé throws.

Ce mot clé permet d'avertir le système qu'une certaine catégorie d'exception ne seront pas traitée en local (dans l'exemple suivant, l'ensemble des exceptions liées aux entrées/sorties).

 
void fonction throws IOException {
    // . . .
}

Le problème est de savoir ce qu'il se passe, si une exception est levée et qu'elle n'est traitée par aucune fonction. Dans ce cas, c'est la JVM qui la traite et affiche sa représentation sous chaîne de caractères (méthode toString appelée). Puis, le système repart la ou il en était.

Définir ses propres exceptions.

Vous pouvez de plus définir vos propres exceptions. Pour ce faire, il vous suffit de définir vos propres classes exceptions, qui devrons dériver de la classe Exception. Au point de vue de la conception, de votre application, il est clair que vous devez y concevoir aussi vos exceptions. Un petit exemple valant mieux qu'un long discours, étudiez le code suivant.

 
public class MonException extends Exception {
    public MonException(String text) {
        super(text);
    }

    public String toString() {
        // . . .
    }
}

Lever une exception.

La question que l'on peut alors se poser, est de savoir comment fait-on pour déclencher une exception. La réponse est très simple : on utilise le mot clé throw.

Le mot clé throw.

Se mot réservé permet donc de lever une exception en instanciant un objet sur une classe dérivée de la classe Exception.

 
throw new MonException("blabla");


Les niveaux d'accès La généricité