Attraper une exception

Nous montrons ici comment se propage une exception et comment on peut attraper une exception qui se propage.

Lorsqu'une exception est lancée, elle va se propager de la façon décrite ci-dessous. Nous supposons que l'exception est lancée par une certaine instruction I (instruction qui peut ressembler à if (...) throw new Exception...();, en supposant qu'à l'exécution, la condition du if est vérifiée) d'une méthode de nom uneMethode. L'explication que nous donnons est récursive.

• Soit l'instruction I se trouve dans un bloc de uneMethode précédé du mot réservé try, bloc que nous appelons "bloc try" suivi d'un bloc précédé du mot réservé catch, bloc que nous appelons "bloc catch", le mot catch étant assorti d'un argument d'une classe ou d'une superclasse de l'exception lancée. Un bloc try est nécessairement suivi par un bloc catch, sans quoi la compilation n'aboutit pas.

  On a donc :

  try {
     ...
     I; // instruction qui lance l'exception
     ...
  }
  catch(TypeDUneException exc {
    ...
  }

  Alors :
  • les instructions qui suivent le lancement de l'exception et intérieures au bloc try sont ignorées (les instructions symbolisées ci-dessus par des points verts),
  • les instructions du bloc catch sont effectuées,
  • le programme reprend normalement avec l'instruction qui suit le bloc catch.
  
  
• Soit l'instruction I n'est pas située comme indiqué ci-dessus, c'est-à-dire n'est pas dans un bloc try.
  Alors, la méthode uneMethode se termine . Si uneMethode est la méthode main, le programme se termine et l'exception n'a pas été attrapée. Sinon, on se retrouve dans la méthode qui a appelée uneMethode, au niveau de l'instruction I' qui a fait appel à uneMethode. L'instruction I' lance à son tour l'exception qui se propage comme expliqé ici.

Si une exception est lancée et pas attrapée, et donc qu'elle provoque la terminaison du programme (plus exactement du thread en cours d'exétion), la pile des méthodes traversées par l'exception est indiquée à l'utilisateur.

Une méthode susceptible de lancer une exception sans l'attraper par le mécanispe try-catch (c'est-à-dire contenant une instruction susceptible de lancer une exception sans que celle-ci soit attrapée à l'intérieur de la méthode) doit l'indiquer dans son en-tête, nous verrons la syntaxe correspondante dans un prochain exemple. Néanmoins, on est dispensé d'indiquer la possibilité de lancement des exceptions les plus courantes, comme par exemple java.lang.ArrayIndexOutOfBoundsException ou bien java.lang.ArithmeticException.

Examinons l'exemple ci-dessous. L'objectif est d'écrire une méthode moyenne qui calcule la moyenne d'entiers reçus en paramètre par un tableau de chaînes de caractères. Les chaînes ne représentant pas un entier (et donc erronées) doivent être ignorées ; l'utilisation des exceptions nous permet ici d'indiquer à l'utilisateur les chaîne erronées. Une méthode main dans la classe EssaiAttrape permet de tester la méthode moyenne. La moyenne calculée est en fait la valeur entière par défaut de la moyenne exact.

public class Attrape {
  public static int moyenne(String[] liste) {
    int somme = 0, nbEntiers = 0;
    
    for (String chaine : liste) {
	try {	    
	    somme += Integer.parseInt(chaine);
	    nbEntiers++;
	  }
	catch (NumberFormatException e) {
	    System.out.println(chaine + " n'est pas entier");
	  }
      }
    return somme/nbEntiers;
  }
}

class EssaiAttrape {
  public static void main(String[] arg) {
    System.out. println("La moyenne est " + Attrape.moyenne(arg));
  }
}

ha n'est pas entier
La moyenne est 13

ha n'est pas entier
15.5 n'est pas entier
java.lang.ArithmeticException: / by zero
        at Attrape.moyenne(ExceptionCatch.java:14)
        at EssaiAttrape.main(ExceptionCatch.java:17)

Pour accéder au fichier Attrape.java.