Exceptions Java

1
Exceptions Java
Les exceptions :
Définition de java.sun.com
Une exception est un évènement qui arrive durant l’exécution d’un programme qui
interrompt le déroulement normal des instructions.
Plusieurs erreurs très différentes peuvent provoquer des exceptions, d’un problème matériel à une simple erreur de
programmation. Lorsque ce genre de chose arrive, une exception est créée et envoyer au système d’exécution. Une exception contient
plusieurs information dont le type d’erreurs, l’état du programme, etc. Le système est alors responsable de trouver le code qui gèrera cette
exception. On appel ce processus lancer une exception.
Le système cherche ensuite « quelqu’un » pour s’occuper de l’exception. L’ensemble des personnes possibles est l’ensemble de
méthode dans la pile des appels (call stack), en commençant par le dessus, puis jusqu’à ce qu’un gestionnaire d’exception approprié soit
trouvé. Un gestionnaire est considéré approprié s’il gère des exceptions du même type que celle lancée. Si aucun gestionnaire n’est
trouvé, le programme se termine.
Les exceptions en JAVA sont des objets qui sont lancées, propagées et attrapées de façon à gérer les erreurs. On peut créer des
objets de type Exception, d’une classe enfant personnelle ou encore utiliser les enfants déjà existant.
Nous diviserons en deux parties l’étude des exceptions. D’abords nous étudierons comment attraper des exceptions lancées par
des méthodes des bibliothèques standards, ensuite, nous verrons comment lancer nos propres exceptions.
Parlons d’abords un peu des exceptions et de leur but. Il y a deux objectifs définis d’utiliser les exceptions, premièrement de
dépolluer le code de plusieurs lignes de validation et deuxièmement créer un code plus stable.
On utilise les exceptions pour traiter les erreurs de façon uniforme tout au long d’un programme, pour gérer les cas exceptionnels
ou difficiles à prévoir.
La base des exceptions : M.O.
Pour gérer une exception (mettons écriture en dehors des bornes d’un tableau) il faut deux choses :
1. Un bloc try
2. Un ou plusieurs blocs catch.
Le bloc try doit contenir la (ou les) ligne de code que l’on croit problématique. Il ne doit pas contenir trop de lignes, sinon d’autres
problèmes pourraient arriver (efficacité).
Un (ou des) bloc « catch » suit immédiatement le bloc « try » et contient la gestion qui sera exécuté dans où une exception serait lancée.
Voici deux exemples relativement simples de gestion des exceptions. Analysez les et n’arrêter que lorsque vous les aurez parfaitement
compris. Simple, parfois, dépend du point de vue.

2
La casse Throwable
Cette classe descend directement de Object : c'est la classe de base pour le traitements des erreurs.
Cette classe possède deux constructeurs :
Méthode
Rôle
Throwable()
Throwable(String)
La chaine en paramètre permet de définir un message qui décrit l'exception et qui
pourra être consultée dans un bloc catch.
String getMessage( )
lecture du message
void printStackTrace( )
affiche l'exception et l'état de la pile d'execution au moment de son appel
void printStackTrace(PrintStream s)
Idem mais envoie le résultat dans un flux
Throwable
Error
Exception
VirtualMachineError
OutOfMemoryError
StackOverflow
LinkageError
NoSuchMethodError
RunTimeException
ClassNotFoundException,
ArithmeticException
NullPointerException
IndexOutOfBoundsException
ClassCastException
InterruptedException

3
Ces mécanismes permettent de renforcer la sécurité du code java.
Exemple : une exception levée à l'exécution non capturée
public class TestException {
public static void main(java.lang.String[] args) {
int i = 3;
int j = 0;
System.out.println("résultat = " + (i / j));
}
}
Résultat :
C:>java TestException
Exception in thread "main" java.lang.ArithmeticException: /
by zero
at tests.TestException.main(TestException.java:23)
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.
Les mots clés try, catch et finally
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.
Exemple :
try {
operation_risquée1;
opération_risquée2;
} catch (ExceptionInteressante e) {
traitements
} catch (ExceptionParticulière e) {
traitements
} catch (Exception e) {
traitements
} finally {
traitement_pour_terminer_proprement;
}

4
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.
Exemple : erreur à la compil car Exception est traité en premier alors que ArithmeticException est une sous classe de Exception
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (Exception e) {
}
catch (ArithmeticException e) {
}
}
}
Résultat :
C:\tests>javac TestException.java
TestException.java:11: catch not reached.
catch (ArithmeticException e) {
^
1 error
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.
Exemple :

5
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("getmessage");
System.out.println(e.getMessage());
System.out.println(" ");
System.out.println("toString");
System.out.println(e.toString());
System.out.println(" ");
System.out.println("printStackTrace");
e.printStackTrace();
}
}
}
Résultat :
C:>java TestException
getmessage
/ by zero
toString
java.lang.ArithmeticException: / by zero
printStackTrace
java.lang.ArithmeticException: / by zero
at tests.TestException.main(TestException.java:24)
Les classes Exception, RunTimeException et Error
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