5.4 Erreurs et exceptions

La notion d'exception décrit des situations où la procédure normale d'évaluation des expressions n'est pas pertinente. Cette procédure suppose que l'évaluation d'une expression (par exemple, d'une invocation de méthode) résulte en la production d'une valeur. Il y a des cas où une valeur n'est pas obtenue, quand la procédure d'évaluation conduirait à exécuter une opération qui ne peut pas ou ne doit pas être réalisée :

• parce qu'une ressource demandée n'est pas disponible : de la mémoire ne peut pas être allouée, un fichier ne peut pas être ouvert, le code d'une classe ne peut pas être chargé, etc ;
• parce qu'une opération n'est pas permise par la sémantique du langage : division entière par zéro, accès à un tableau hors de ses bornes ;
• parce qu'une opération n'est pas permise par la sémantique de l'application : accéder au fils gauche d'un arbre vide.

Il est donc possible que l'évaluation d'une expression, au lieu de retourner une valeur, déclenche une exception. Certaines de ces exceptions sont des erreurs, qui conduisent fatalement à une fin prématurée du programme. D'autres peuvent être récupérées pour permettre la poursuite du programme.

5.4.0.0.1 Une hiérarchie d'exceptions

En Java, les exceptions sont représentées par des objets de classe java.lang.Throwable, qui a deux sous-classes. La sous-classe Error est formée des exceptions qui ne sont pas considérées comme récupérables ; elles concernent les opérations de la Machine Virtuelle Java.

La sous-classe Exception est formée des exceptions considérées comme récupérables. Cependant, les objets de la sous-classe RuntimeException d'Exception ne sont pas obligatoirement récupérables : cette sous-classe comporte les exceptions

• ArithmeticException,
• ArrayStoreException,
• NullPointerException,
• IndexOutOfBoundsException, etc.

Les autres sous-classes d'Exception sont formées d'exceptions qui doivent être récupérées : par exemple,

• java.io.FileNotFoundException,
• java.net.UnknownHostException,
• InterruptedException.

Ces exceptions sont dites contrôlées parce que le compilateur vérifie comment elles sont traitées. Les exceptions définies par le programmeur sont des sous-classes d'Exception ; elles sont donc contrôlées.

Une méthode qui est susceptible de lever une exception contrôlée doit :

• soit intercepter l'exception et la traiter (par un try ... catch) ;
• soit déclarer que cette exception est propagée (par un throws).

Cette déclaration, sous la forme d'une liste d'exceptions, intervient dans la relation de typage.

5.4.0.0.2 Récupération

L'interception et le traitement sont réalisés en plaçant les appels susceptibles de déclencher une exception dans un try ... catch. La récupération minimale, qui gobe n'importe quelle exception, sans rien dire, est :

  try {
  ...
  }
  catch (Exception e) {}

Une version plus informative de cette récupération minimale consiste à imprimer la chaîne de caractères décrivant l'exception sur le flot de sortie en erreur standard, par System.err.println(e), ou mieux, à imprimer l'état de la pile :

    try {
      ...
    }
    catch (Exception e) {
      System.err.println("Exception: " + e.getMessage());
      e.printStackTrace()
    }

Ce style de programmation est nécessaire dans des logiciels qui doivent être robustes.

5.4.0.0.3 Déclenchement

Le déclenchement d'une exception provoque d'une part la sortie immédiate de la méthode, et d'autre part le dépilage des appels jusqu'à ce qu'apparaisse un cadre d'invocation d'une méthode contenant un catch : l'exception est donc propagée le long de la chaîne des invocations tant qu'elle n'est pas récupérée. Ce mécanisme de propagation est distinct du mécanisme usuel de retour d'une méthode. Si l'exception n'est jamais récupérée, le programme termine anormalement.

Le programmeur peut déclencher explicitement une exception grâce à l'instruction throw :

    throw new Exception("message explicatif");

5.4.0.0.4 Nouveaux types d'exception

Il est parfois nécessairede définir son propre type d'exception, pour identifier une catégorie particulière de situation. On procède par extension du type Exception, avec les deux constructeurs suivants, le second permettant d'associer un message textuel au déclenchement d'une exception :

class MonException extends Exception {

  MonException() {}

  MonException(String message) {
    super(message);
  }