Ce document a pour but de se familiariser avec les Exceptions en Java. 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). Il existe plusieurs types d'exceptions, par exemple mathématiques (division par zéro), de type … Il est également possible de créer des types d'exception personnalisés. Par défaut, Java couvre un très large domaine en terme de type d'exceptions.

Ce bloc contient les instructions suceptibles de générer des erreurs ou des exceptions. Si une erreur ou une exception survient dans le bloc Try lors de l'exécution d'une instruction, les instructions qui suivent (dans ce bloc) ne seront pas exécutées.

	try 
	{
	       instruction1
	       instruction2
	       instruction3
	       instruction4
	}

Lorsqu'une exception ou une erreur survient dans le bloc Try, le bloc Catch intercepte l'exception pour la traiter en exécutant les instructions qu'il contient. On peut par exemple afficher l'erreur ou bien informer l'utilisateur qu'il tente d'ouvrir un fichier déjà ouvert. Il est cependant il est impératif de spécifier au Catch le type de l'exception qu'il devra intercepter. Le fait d'intercepter une exception aura pour résultat la création d'un Objet. Si ce bloc ne contient aucune instruction alors l'exception sera ignorée. Ce qui n'est pas très propre.

	catch ( [type d'exception] [variable] ) 
	{
       		instruction(s)     //Traitement de l'exception
       	}

Les instructions contenues dans ce bloc seront exécutées qu'une exception soit survenue ou non. Ce bloc n'est pas obligatoire mais peut s'avérer très pratique dans certains cas. Par exemple, si une erreur survient lors de l'écriture dans un fichier, on aura pensé à placer dans le bloc Finallly une instruction se chargeant de la fermeture du fichier.

	finally 
	{
	       instructions
	}

Une méthode suivie de throws type_exception permet d'indiquer au compilateur que la méthode en question est capable de lever l'exception son traitement sera assuré par la méthode appelante. Les méthodes qui l'appellent devront donc prendre en compte cette exception (traitement ou propagation).

	void f( ) throws IOException
	{
        	instruction(s)
	}

Cette fonction f( ) est capable de lever une exception du type IOException mais ne la traitera pas. Il faut donc que le traitement ou la propagation soit assurée par la méthode appelante.

En Java, il est possible de lever une exception en utilisant le mot clé Throw. Lorsqu'une exception est levée, il y a création d'un objet dérivant du type java.lang.Exception. Cet objet contiendra par exemple un message d'erreur de type String. Si la méthode levant l'exception ne la traite pas et est suivie du mot clé throws, cet objet sera passé à la méthode appelante.

	throw new MonException("Il y a une erreur");

En Java, il est possible d'intercepter plusieurs exceptions de types différents pourvu que tous ces types d'exceptions héritent du même type parent. Le Catch surveillera donc les exceptions du type du père des toutes ces exceptions. Par exemple, si le type attendu est java.lang.RuntimeException alors il interceptera les exceptions de types BufferUnderflowException, IndexOutOfBoundsException, … (voir la JavaDoc).

Il est possible voir des fois nécessaire d'utiliser plusieurs Catch afin d'intercepter des exceptions de types différents et d'effectuer traitement propre à chaque type d'exception.