Explications
try_statement
::=
"try" statement
{ "catch" "(" parameter ")" statement }
[ "finally" statement ]
This rule is called by-> statement
Explicationstry est utilisée pour le traitement des
exceptions.
Typiquement, la configuration sera la suivante :
try {
operation_dangereuse_1;
operation_dangereuse_2;
operation_dangereuse_3;
} catch (ExceptionInteressante except) {
// on ne traite pas cette exception
} catch (ExceptionParticuliere except) {
traite_cas_particulier;
} catch (Exception except) {
traite_l'exception;
} finally {
termine_proprement;
}
opérations dangereuses
on saute immédiatement à la fin du bloc, sans exécuter les opérations
suivantes, de la même manière que break. Ensuite, on teste
successivement les différents paramètres des éléments catch.
Si l'exception générée est de la même classe (ou d'une sous-classe) que
l'objet déclaré dans la clause catch, alors on exécute son
contenu. Si ce n'est pas le cas, on teste le catch suivant.
Si l'exception en question n'a pas été traitée par un bloc catch,
l'exception sera transmise au bloc supérieur.
La clause finally délimite un bloc qui sera exécuté de toute
façon, qu'une exception soit générée ou pas. Ce bloc est également exécuté
si dans le corps de l'instruction try, on renconte
break ou continue. On peut l'utiliser pour fermer
des fichiers, par exemple.
Attention !IOException avant Exception.
Exemple
class divisionParZeroException extends Exception {
}
class operationInconnueException extends Exception {
public operationInconnueException(String s) {
super(s);
}
}
class divMul {
private static int execOperation(int operande1,String operation,int operande2)
throws divisionParZeroException, operationInconnueException {
if ("*".equals(operation))
return operande1*operande2;
else if ("/".equals(operation)) {
if (operande2 == 0)
throw new divisionParZeroException();
return operande1/operande2;
} else
throw new operationInconnueException(operation);
}
public static void main (String args[]) {
System.out.println("exemple de traitement d'exceptions");
int operande1[] = {3, 56, 33, 25};
String operation[] = {"*","/","+","/"};
int operande2[] = {5, 4, 5, 0};
for (int n = 0;n < operande1.length;n++) {
try {
System.out.println("Calcul de "+operande1[n]+operation[n]+operande2[n]);
System.out.println("Resultat = "+execOperation(operande1[n],operation[n],operande2[n]));
} catch (divisionParZeroException e) {
System.out.println("Division par zero.");
} catch (operationInconnueException e) {
System.out.println("Operation inconnue : "+e.getMessage());
} catch (Exception e) {
System.out.println("une autre exception est survenue.");
} finally {
System.out.println("clause finally appellee");
}
}
}
}
Exécution
exemple de traitement d'exceptions
Calcul de 3*5
Resultat = 15
clause finally appellee
Calcul de 56/4
Resultat = 14
clause finally appellee
Calcul de 33+5
Operation inconnue : +
clause finally appellee
Calcul de 25/0
Division par zero.
clause finally appellee