• Vendredi 3 juillet 2009 - 16:49:44
• inscrits : 1500007
• connectés : 58749
• questions/jour : 4727
• Taux de réponse : 76.3%

La nécessité de détecter les erreurs

Tout programme comporte des erreurs, même si celui-ci semble fonctionner à merveille. Chaque programmeur essaye de réduire au minimum le nombre d'erreurs, mais toutes les erreurs ne peuvent pas forcément être prévues.

Les erreurs syntaxiques sont la plupart interceptées lors de la compilation, mais il reste souvent des erreurs "imprévisibles".
Ces erreurs se produisent généralement de façon exceptionnelle, c'est-à-dire suite à une action de l'utilisateur, ou de l'environnement. La solution consiste donc dans un premier temps à "prévoir les erreurs imprévisibles" en mettant en place un système de codes d'erreurs, c'est-à-dire un système permettant de retourner des valeurs spécifiques pour signaler un fonctionnement anormal de l'application (souvent -1 ou NULL).

Toutefois cette solution est loin d'être satisfaisante car :

• elle rend difficile l'écriture de programmes
• elle rend difficile la lecture du code source, à cause d'une embrication de test conditionnels (if .. else)
• le code d'erreur retournée peut-être confondue avec la valeur retournée par la fonction... (-1 peut très bien être la valeur de retour d'une fonction)

La notion d'exception

Pour traiter les erreurs, Java propose un mécanisme qualifié d'exception, consistant à effectuer les instructions dans un bloc d'essai (le bloc try) qui surveille les instructions. Lors de l'apparition d'une erreur, celle-ci est lancée dans un bloc de traitement d'erreur (le bloc catch, appelé handler d'exception) sous forme d'un objet appelé Exception.

Le bloc de traitement d'erreur va lever (il s'agit du terme technique, certains diront aussi intercepter) l'exception. Le handler d'exception peut alors traiter l'erreur (en signalant l'erreur par exemple, ou en attendant avant de réessayer, ...) puis lancer à nouveau l'exception vers un bloc de plus haut niveau.

Il est important de souligner que la transmission des exceptions est d'abord *implicite*. C'est bien évidemment pour cette raison que le concept d'exception est un réel progrès pour l'écriture d'un code facile à lire.

Les exceptions par la pratique

La gestion des exceptions avec Java consiste à définir au sein d'une méthode une clause "try{}" contenant les instructions qui risquent de provoquer une exception et de la faire suivre immédiatement par une clause "catch(){}" contenant comme paramètre l'exception attendue précédée de son type (pour une erreur mathématique ce sera ArithmeticException) et dont le contenu sera une liste d'instruction à exécuter lorsque l'exception se produira.

Voici la syntaxe type d'une classe gérant des exceptions :

class Nom_de_la_classe {
	public static void main(String[] args) {
	// Instructions inoffensives (affectations, ...);
	try {
	// Instructions susceptibles de provoquer des erreurs;
	}
	catch (TypeException e) {
	// Instructions de traitement de l'erreur;
	}
	// Instructions si aucune erreur est apparue;
	} 
}

• Aucune instruction ne doit se trouver entre le bloc try{} et le bloc catch{}
• Les blocs try{} et catch{} peuvent chacun contenir plusieurs instructions

Comment les exceptions sont-elles traitées?

Lorsque le programme rencontre une exception dans un bloc try{}, une exception est instanciée puis lancée. L'interpréteur cherche un bloc catch(){} à partir de l'endroit où l'exception a été créée en cherchant vers le bas. S'il ne trouve aucun bloc catch{}, l'exception est lancée dans le bloc de niveau supérieur, ainsi de suite jusqu'au bloc de la classe qui par défaut enverra l'exception au handler de l'interpréteur. Celui-ci émettra alors un message d'alerte standard pour le type d'exception.

Si jamais un bloc catch{} est trouvé, celui-ci gèrera l'exception à sa façon (ou plutôt à la votre) et l'exception ne sera pas envoyée au handler de l'interpréteur.

Si par contre on désire que l'exception soit traité par les blocs de niveaux supérieurs, il suffit d'inclure à la fin de la série d'instructions contenues dans le bloc catch{} une clause throw, suivie du type de l'exception entre parenthèse puis du nom de l'exception (son handle pour utiliser un terme exact). Ainsi l'exception continuera son chemin...

class Nom_de_la_classe {
	public static void main(String[] args) {
	// Instructions inoffensives (affectations, ...);
	try {
	// Instructions susceptibles de provoquer des erreurs;
	}
	catch (TypeException e) {
	// Instructions de traitement de l'erreur;
	throw (TypeException)e;
	}
	// Instructions si aucune erreur est apparue;
	} 
}