INF1563 Programmation I

Traitement des exceptions

Voir aussi :

Notes de cours de Philippe Genoud

Introduction

plusieurs types d'erreurs !
mais c'est rare que suite à une détection d'une erreur, l'exécution doit être terminée
des erreurs fatales (non récupérables) : le programme s'arrête à la suite de ce type de situation
des erreurs récupérables : le programme exécute une action corrective et poursuit son exécution
une erreur corrigible = un signal indiquant qu'une situation anormale a eu lieu

exemples : division par zéro, une erreur syntaxique dans un programme, une mauvaise commande dans un système d'exploitation, l'absence d'un fichier, mémoire insuffisante
attention : il n'est pas nécessaire que la gestion d'une exception se trouve dans la méthode qui est susceptible de déclencher cette exception;
une méthode peut ignorer la gestion d'une exception à condition qu'elle transmette l'exception à la méthode appelante

Traitement d'erreurs en Java

Java supporte les deux types d'erreurs :
- les erreurs fatales sont représentées par des objets de la classe java.lang.Error
- les erreurs récupérables sont appelées des exceptions et sont représentées par des objets de la classe java.lang.Exception
hiérarchie des classes
- Object
  - Throwable
    - Error
      - AssertionError
      - ...
    - Exception
      - RuntimeException
        
        NullPointerException
        
        IndexOutOfBoundsException
        
        ArrayIndexOutOfBoundsException
        
        StringIndexOutOfBoundsException
        
        ArithmeticException
        
        MonException1
      - IOException
        
        EOFException
        
        FileNotFoundException
      - ...
      - MonException2
  - ...

Traitement d'exceptions

lorsqu'une situation anormale est détectée, une exception est lancée
si cette exception n'est pas attrapée dans le bloc de code où elle a été lancée, elle est propagée au niveau du bloc englobant
si ce dernier ne l'attrape pas, elle est transmise au bloc de niveau supérieur et ainsi de suite
si l'exception n'est pas attrapée dans la méthode qui l'a lancée, elle est propagée dans la méthode qui a invoqué cette dernière
si la structure de bloc de la méthode d'invocation ne contient aucune instruction attrapant l'exception, celle-ci est à nouveau propagée vers la méthode de niveau supérieur
si une exception n'est jamais attrapée (incluant la méthode main()), un message d'erreur et le contenu de la pile des appels sont affichés et le programme s'arrête

Techniquement, les exceptions sont traitées à l'aide de la construction

try {
  instructions
}
catch (class d'exception e) {
  instructions
}
...
catch (class d'exception e) {
  instructions
}

try { .. } détermine une séquence d'instructions susceptibles de déclencher une exception
catch (class d'exception e) { ... } attrappe les exceptions de type indiqué et exécute les actions nécessaires pour traiter la situation qui a déclenché l'exception attrapée
si une instruction du bloc try déclenche une exception
- les instructions du bloc try qui la suivent ne sont pas exécutées
- les instructions du bloc catch son exécutées
- le programme reprend son cours normalement avec l'instruction suivant le bloc catch

Exemple (version 1) :

But : calculer le double des valeurs entières passées sur la ligne de commande.

public class Exemple {

  public static void main(String args[]) {
    for (int i=0; i<args.length; i++){
      System.out.println(Integer.parseInt(args[i]) * 2);
    }
  }
}

java Exemple 12 45 3a 78

Exception in thread "main" java.lang.NumberFormatException: For input string: "3a"
  at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
  at java.lang.Integer.parseInt(Integer.java:458)
  at java.lang.Integer.parseInt(Integer.java:499)
  at Exemple.main(Exemple.java:7)
24
90

Exemple (version 2) :

public class Exemple {

  public static void main(String args[]) {
    try {
      for (int i=0; i<args.length; i++){
        System.out.println(Integer.parseInt(args[i]) * 2);
      }
    }
    catch (NumberFormatException e){
      System.out.println(1);
    }
  }
}

java Exemple 12 45 3a 78

24
90
1

Exercice

Quelle valeur sera affichée par le programme suivant ?

public class Quiz {

  public static void main(String args[]) {

    try {
      int i = 0;
      System.out.println(5/i);
      System.out.println(10);
    }
    catch (NumberFormatException e){
      System.out.println(20);
    }
    catch (ArithmeticException e){
      System.out.println(30);
    }
    catch (Exception e){
      System.out.println(40);
    }
  }
}

Les exceptions de la classe RuntimeException

la classe mère des exceptions qui peuvent être déclenchées au cours de l'exécution d'un programme
une méthode ne doit pas nécessairement déclarer dans sa clause throws toute sous-classe de RuntimeException qui pourrait être déclenchée durant l'exécution de la méthode mais ne pas être attrapée
l'exception NumberFormatException est une sous-classe de RuntimeException

Définition de nouveaux types d'exceptions

si l'on veut signaler une situation exceptionnelle, non prévue par l'API de Java, il faut dériver la classe Exception et définir une nouvelle classe
cette classe contient en général une redéfinition de la méthode toString
lors du lancement d'une telle exception avec l'instruction throw, on crée une instance de cette nouvelle classe
la méthode susceptible de lance l'exception x qui n'est pas une sous-classe de RuntimeException, doit avoir la clause throws x à la fin de sa signature

Exemple :

class NoteException extends Exception {
  public String toString() {
    return("Une note trop basse !\n");
  }
}

Exemple :

public class NoteException extends Exception {
  int noChapitre;
  public String toString() {
    return("Une note trop basse pour le quiz " + noChapitre + " !\n");
  }
}

public class Quiz {
  int note;
  ...
}

public class Cours {

  static Quiz q[] = new Quiz[10];

  void verifierQuiz() throws NoteException {
    for (int i=0; i<q.length; i++){
      if (q[i].note < 1)
        throw new NoteException();
      else
        System.out.println("la note pour le quiz " + i + " est " + q[i].note);
    }
  }

  void reprendreChapitre(int no){
    ...
  }

  public static void main(String args[]) {

    Cours inf1563 = new Cours();
    ...
    try {
      inf1563.verifierQuiz();
    }
    catch (NoteException e){
      System.out.println(e.toString());
      inf1563.reprendreChapitre(e.noChapitre);
    }
  }
}

Remarque : Toute méthode susceptible de déclencher une exception n'étant pas une sous-classe de RuntimeException doit

soit l'attraper
soit la déclarer explicitement avec la clause throws

Une mauvaise pratique

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

le bloc "finally"

les clauses catch sont suivies optionnellement par un bloc finally

...
try {
  // ouvrir un fichier et effectuer certains traitements
  // susceptibles de déclencher l'exception IOException
}
catch (IOException e) {
  // traiter l'exception
}
catch (Exception e){
  // traiter d'autres exceptions si c'est le cas
}
finally {
  //fermer le fichier
}

le bloc finally contient du code qui sera exécuté quelle que soit la manière dont le bloc try a été quitté
son exécution est garantie peu importe si
- le bloc try s'est exécuté normalement sans aucune exception déclenchée
- le bloc try déclenche une exception attrapée par l'un des blocs catch
- le bloc try déclenche une exception qui n'est attrapée par aucun des blocs catch qui le suivent