Les exceptions
Introduction
Les exceptions servent à gérer les
erreurs qui peuvent arriver dans un
programme.
Connexion à une base de données échouée.
Erreur de programmation : une méthode
appliquée sur une référence nulle.
Pas de gestion automatique d’exceptions :
obligation de débrouiller avec code
d’erreur.
Les exceptions : les
outils
Attraper les exceptions : try, catch,
finally
Lancer des exceptions : throw
Signaler les exceptions non attrapées :
throws
ArrayIndexOutOfBoundsExceptions
public class TestException {
public static void main (String [] args) {
int[] t=new int [5]; // indices de 0 à 4
[Link](“début “);
Int x= t[5]; // arrêt du programme
[Link](“affectation réussie!“);
} }
Une exception non attrapée provoque l’arrêt du
programme
ArithmeticException
public class TestException {
public static void main (String [] args) {
int[] t={6,2,7,9,7};
[Link](“début “);
Int x= 1/(t[4]-t[2]) ; // arrêt du programme
[Link](“affectation réussie!“);
}}
Ici aussi, l’exception non attrapée provoque
l’arrêt du programme
Lancer, attraper une exception
En cas d’anomalie( index en dehors des limites, division par zéro…),
une exception est lancée
Une exception lancée et n’est pas attrapée
provoque l’arrêt du programme
avec un message d’erreur
Pour gérer les exceptions,
On utilise des instructions JAVA spécifiques
MOT-CLES liés aux exceptions:
try, catch, finally, throw, throws
Classe d’exceptions
Une exception est une instance d’une classe
d’exception
La classe [Link] est la classe racine
des classes d’exceptions.
Quelques classe d’exceptions :
ArithmeticException (pour des erreurs comme la
division par zéro)
ArrayIndexOutOfBoundsException (indice <0 ou>=au
nombre d’éléments du tableau, du vecteur…)
NumberFormatException ( une chaîne qui n’a pu être
convertie en nombre)
FilleNOTfoundException ( fichier non trouvé)
Quelques classes prédéfinies
d’exceptions
Throwable
Error
Exception
LinkageError
RuntimeException
NoSuchMethodError ClassFormatError
IOException
ArrayIndexOutOfBoundsException NullPointerException
ArithmeticException EOFException FileNotFoundException
catch : pour attraper les
exceptions
public class TestException {
public static void main (String [] args) {
int[] t={6,2,7,9,7};
try {
[Link](“début “);
Int x= 1/(t[4]-t[2]) ;
[Link](“affectation reussie!“);}
catch (ArithmeticException e) {
[Link] ( “Operation impossible “ ); }
[Link](“Fin“) ;
} }
catch multiples
public class TestException {
public static void main (String [] args) {
int[] t={6,2,7,9,7};
try {
[Link](“début “);
Int x= 1/(t[4]-t[2]) ; Int y=t [5];
[Link](“affectation reussie!“);}
catch (ArithmeticException e) {[Link] ( “Operation
impossible “ ); }
Catch(ArrayIndexOutofBoundsException e ) {[Link] (
“Operation impossible “ ); }
[Link](“Fin“) ; } }
Où capturer les exceptions?
public class TestException {
public static void affectation( int i, int [] tab) {
Int x=1/(tab[i+2] –tab[i] ); int y =tab[i+4] ;} les
exceptions sont souvent capturées
public static void main (String [] args)
{ dans les fonctions appelantes
int[] t={6,2,7,9,7};
try {
[Link](“début “);
affectation(2,t);
[Link](“affectation reussie!“);}
catch (ArithmeticException e) {[Link] ( “Operation impossible “ ); }
catch(ArrayIndexOutofBoundsException e ) {[Link] ( “Indice incorrect “ ); }
[Link](“Fin“) ; } }
Où capturer les exceptions ?
public class TestException {
public static void affectation( int i, int [] tab) {
try {
Int x=1/(tab[i+2] –tab[i] ); int y =tab[i+4] ;
Le contrôle est transmis au
catch (ArithmeticException e) {[Link] ( “Operation impossible “ ); }
premier bloc catch de la bonne classe
[Link](“Fin de effectuer “);
public static void main (String [] args) {
int[] t={6,2,7,9,7};
try {
[Link](“début “);
affectation(2,t);
[Link](“affectation reussie!“);}
catch(ArrayIndexOutofBoundsException e ) {[Link] ( “indice incorrect “ ); }
Finally: à exécuter quoiqu’il
arrive?
public class TestException {
public static void affectation( int i, int [] tab) {
try {
Int x=1/(tab[i+2] –tab[i] ); int y =tab[i+4] ;
catch (ArithmeticException e) {[Link] ( “Operation impossible “ ); }
Finally {[Link] ( “Fin de effectuer“ ); }
[Link](“Fin de effectuer “); }
public static void main (String [] args) {
int[] t={6,2,7,9,7};
try {
[Link](“début “);
affectation(2,t); [Link](“affectations terminees!“);}
catch(ArrayIndexOutofBoundsException e ) {[Link] ( “indice incorrect “ ); }
[Link](Fin) ; } }
Finally: illustration
public class TestException {
public static void main (String [] args) {
int[] tab={6,2,7,9,7};
try{
try {
[Link]("début ");
int x=1/(tab[4]-tab[2]);
int y=tab[6];
[Link]("affectations terminees!");
}catch(ArrayIndexOutOfBoundsException e ){
[Link] ("indice incorrect "); }
finally {
[Link] ("Fin de affectuer"); }
}catch (ArithmeticException e) {
[Link] ("Operation impossible "); }
[Link]("Fin") ;
} }
Execution
Début
Fin de affectuer
Operation impossible
Fin
Comment déclencher une exception avec
throw nous même
Considérons une classe Point, munie d'un constructeur à deux
arguments et d'une méthode affiche
Supposons que nous manipulons que des points ayant des
coordonnées non négatives.
Nous pouvons, au sein du constructeur, vérifier la validité
des paramètres fournis.
Lorsque l'un d'entre eux est incorrect, nous "déclenchons" (on
emploie aussi les verbes "lancer" ou "lever") une exception à
l'aide de l'instruction throw.
A celle-ci, nous devons fournir un objet dont le type servira
ultérieurement à identifier l'exception concernée.
Suite (2)
Nous créons donc (un peu artificiellement) une classe que
nous nommerons ErrConst
Java impose que cette classe dérive de la classe standard
Exception: class ErrConst extends Exception { } ;
Pour lancer une exception de ce type au sein de notre
constructeur, nous fournirons à l'instruction throw un
objet de type ErrConst, par exemple de cette façon :
throw new ErrConst(); (Objet anonyme)
Suite (3)
Suite(3)
En définitive, le constructeur de notre classe Point peut se présenter ainsi :
Dans l'en-tête du constructeur, throws ErrConst , précise que la
méthode est susceptible de déclencher une exception de type ErrConst.
Cette indication est obligatoire en Java, à partir du moment où
l'exception en question n'est pas traitée par la méthode elle-même.
Utilisation d'un gestionnaire
d'exception
• Comment procéder pour gérer convenablement les
éventuelles exceptions de type ErrConst que son
emploi peut déclencher.
• Pour ce faire, il faut :
1- inclure dans un bloc particulier dit "bloc try"
les instructions dans lesquelles on risque de
voir déclenchée une telle exception ;
2- faire suivre ce bloc de la définition des
différents gestionnaires d'exception (ici, un
seul suffit). Chaque définition de gestionnaire
est précédée d'un en-tête introduit par le mot
clé catch (comme si catch était le nom d'une
méthode gestionnaire).
Suite (1)
Si une exception est déclenchée par une instruction situé dans le bloc
try, alors :
1-Le programme abandonne l'exécution du code restant dans le bloc
try.
2-Le programme exécute le code du gestionnaire situé dans la clause
catch.
Suite(2)
• Si aucune des instructions du bloc try ne lance
une exception, le programme ignore la clause
catch.
• Ce premier exemple est très restrictif pour
différentes raisons :
1- on n'y déclenche et on ne traite qu'un seul type
d'exception ;
2- le gestionnaire d'exception ne reçoit aucune
information ; plus exactement, il reçoit un objet
sans valeur qu'il ne cherche pas à utiliser ;
3- nous n'exploitons pas les fonctionnalités de la
classe Exception dont dérive notre classe ErrConst
;
4- le gestionnaire d'exception se contente
d'interrompre le programme alors qu'il est
possible de poursuivre l'exécution.
Gestion de plusieurs exceptions
Nous considérons une classe Point munie :
du constructeur précédent, déclenchant toujours
une exception ErrConst,
d'une méthode déplace qui s'assure que le
déplacement ne conduit pas à une coordonnée
négative ; si tel est le cas, elle déclenche une
exception ErrDepl (on crée donc, ici encore, une
classe ErrDepl) :
Gestion de plusieurs exceptions
Nous nous contentons comme précédemment d'afficher un message et
d'interrompre l'exécution
Transmission d'information au
gestionnaire d'exception
On peut transmettre une information au
gestionnaire d'exception :
1- par le biais de l'objet fourni dans
l'instruction throw,
2- par l'intermédiaire du constructeur de
la classe Exception.
Par l'objet fourni à
l'instruction throw
Par le constructeur de la classe
Exception
Poursuite de l'exécution
Choix du gestionnaire
d'exception
Cheminement des exceptions et la
clause throws
Lorsqu'une méthode déclenche une exception, on
cherche tout d'abord un gestionnaire dans
l'éventuel bloc try contenant l'instruction throw
correspondant.
Si l'on n'en trouve pas ou si aucun bloc try n'est
prévu à ce niveau, on poursuit la recherche dans un
éventuel bloc try associé à l'instruction d'appel
dans une méthode appelante, et ainsi de suite.
Toute méthode susceptible de déclencher une
exception qu'elle ne traite pas localement doit
mentionner son type dans une clause throws figurant
dans son en-tête. Lorsqu'il existe plusieurs
exceptions, il faut toutes les mentionner en les
séparant par l'opérateur virgule.
Cheminement des exceptions et la clause
throws
Redéclenchement d'une
exception
Dans un gestionnaire d'exception, il est
possible de demander que, malgré son
traitement, l'exception soit retransmise à un
niveau englobant, comme si elle n'avait pas
été traitée. Il suffit pour cela de la
relancer en appelant à nouveau l'instruction
throw.
Cette possibilité de re-déclenchement d'une
exception s'avère très précieuse lorsque l'on
ne peut résoudre localement qu'une partie du
problème posé.
Redéclenchement d'une exception
Le bloc finally
Java permet d'introduire, à la suite d'un
bloc try, un bloc particulier
d'instructions qui seront toujours
exécutées :
soit après la fin "naturelle" du bloc try,
si aucune exception n'a été déclenchée .
soit après le gestionnaire d'exception (à
condition, bien sûr, que ce dernier n'ait
pas provoqué d'arrêt de l'exécution).
Ce bloc est introduit par le mot clé
finally et doit obligatoirement être placé
après le dernier gestionnaire. Voici un
exemple de code, accompagné de deux
exemples d'exécutions :
Le bloc finally
Exemple
un exemple de programme qui détecte les exceptions standard NegativeArraySizeException
et ArrayIndexOutOfBoundsException et qui utilise la méthode getMessage pour afficher le
message correspondant
pas
Exemple : gérer les erreurs sans les exceptions
Avec les exceptions: