Chapitre 7 : La gestion des 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'execution jusqu'à ce qu'il soit traitée.

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

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. Les erreurs et exceptions du paquetage java.lang échappe à cette contrainte. 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.

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.

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 (aucunes instructions entre les accolades) alors l'exception capturée est ignorée.

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.

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ées 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 regé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.

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.

Cette classe descend directement de Object : c'est la classe de base pour le traitements des erreurs.

Cette classe possède deux constructeurs :

Les principales méthodes de la classe Throwable sont :

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 instantanement 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

Pour générer une exception, il suffit d'utiliser le mot clé throw, suivi d'un objet dont la classe dérive de Thowable. 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 ces 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 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 déclared in the thows clause of this méthode.

Java n'oblige la déclaration des exceptions dans l'en tête de la méthode que pour les exceptions dites controlées (checked). Les exception non controlées (unchecked) peuvent être capturée mais n'ont pas a être déclarée. Les exceptions et erreurs qui héritent de RunTimeException et de Error sont non controlées. Toutes les autres exceptions sont controlées.