try_statement

try_statement 
      ::= 
      "try" statement 
      { "catch" "(" parameter ")" statement } 
      [ "finally" statement ] 

[rule list]
This rule is called by

-> statement

Explications

La clause try 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;
}
Si une exception est générée par une des 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 !

Il faut faire attention à bien traiter les exceptions "les plus précises" (les sous-classes) avant les exceptions générales, pour les raisons évoquées plus haut. On veillera donc à tester l'exception 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

Index général - Index concepts - Règles BNF
© 1996, DIP Genève, Alexandre Maret & Jacques Guyot
page générée Fri Jun 21 15:41:14 MET DST 1996