Conception par Objet et Programmation Java

Ce document présente les concepts fondamentaux des exceptions en programmation Java, destinés aux étudiants et développeurs souhaitant comprendre la gestion des erreurs et améliorer la robustesse de leurs programmes. Il couvre la définition, le mécanisme, les types d’exceptions, la gestion avec try/catch, ainsi que la création d’exceptions personnalisées.

Définition et nature des exceptions

Une exception est un événement exceptionnel qui survient lors de l’exécution d’un programme et qui interrompt son déroulement normal. Elle signale une erreur ou une situation anormale, comme une division par zéro, un accès hors limites dans un tableau, une saisie invalide, un fichier inexistant, ou un manque de mémoire.

Exemple d’exception levée mais non capturée :

public class Exemple {
  public static void main(String[] args) {
    int x = 10, y = 0, z;
    z = x / y;
  }
}

Ce code compile sans erreur, mais à l’exécution, il provoque :

Exception in thread "main" java.lang.ArithmeticException: / by zero at Erreur.main(Erreur.java:4)

Mécanisme des exceptions

Le mécanisme d’exception suit trois étapes :

1. Émission d’un signal : l’exception est levée (déclenchée).
2. Interruption de l’exécution normale du programme.
3. Possibilité d’attraper (intercepter) l’exception pour la traiter et éviter l’arrêt définitif du programme.

Le programmeur ou la machine Java peut déclencher une exception. Le mot-clé throw permet de forcer la génération d’une exception en créant un objet exception.

Types d’exceptions

La hiérarchie des exceptions en Java est organisée autour de la classe de base Throwable, qui possède deux sous-classes principales :

• Error : erreurs liées à la machine virtuelle, généralement irrécupérables (exemple : LinkageError, ThreadDeath).
• Exception : exceptions gérées par le programmeur, regroupant notamment :

• RuntimeException : erreurs d’exécution non vérifiées (unchecked), comme ArithmeticException.
• Checked exceptions : exceptions vérifiées, comme IOException, qui doivent être déclarées avec throws ou gérées avec try/catch.

Les exceptions unchecked n’exigent pas la déclaration throws, tandis que les checked l’exigent.

Exemple d’exception unchecked

public class TestException {
  public static void main(String[] args) {
    int a = 5, b = 0, c;
    c = a / b;
    System.out.println("le résultat " + c);
  }
}

Ce code provoque une ArithmeticException à l’exécution.

Gestion d’une exception unchecked avec try/catch

public class TestException {
  public static void main(String[] args) {
    try {
      int a = 5, b = 0, c;
      c = a / b;
      System.out.println("le résultat " + c);
    } catch (ArithmeticException ex) {
      System.out.println(ex);
    }
  }
}

Gestion avec poursuite du programme

public class TestException {
  public static void main(String[] args) {
    try {
      int a = 5, b = 0, c;
      c = a / b;
      System.out.println("le résultat " + c);
    } catch (ArithmeticException ex) {
      System.out.println(ex);
    }
    System.out.println("poursuite du programme");
  }
}

Exemple d’exception checked

Certaines méthodes, comme le constructeur java.io.PrintWriter, peuvent lancer des exceptions checked (ex : IOException) qui doivent être gérées explicitement :

• Gestion active avec try/catch
• Gestion passive avec throws

Gestion des exceptions en Java

Deux approches principales existent pour gérer une exception :

• Traitement local dans le bloc de code où l’exception peut survenir.
• Transmission de l’exception à la méthode appelante, qui décidera de la gérer ou non.

Syntaxe de base pour gérer une exception localement

try {
  // bloc susceptible de provoquer une exception
} catch (TypeDexception e) {
  // traitement de l'exception
}

Bloc finally

Le bloc finally est un bloc optionnel qui suit un try ou un try avec un ou plusieurs catch. Il contient des instructions qui s’exécutent toujours, que l’exception soit levée ou non, gérée ou non, ou même en cas de return, break, ou continue.

Exemple :

try {
  // code pouvant lever une exception
} catch (IOException ioex) {
  // traitement de l'exception
} finally {
  // code exécuté systématiquement (nettoyage, fermeture de ressources)
}

Un bloc try peut aussi être suivi uniquement d’un finally sans catch.

Exceptions personnalisées

Il est possible de créer ses propres classes d’exceptions pour adapter le comportement aux besoins spécifiques d’un programme, plutôt que d’utiliser uniquement les exceptions standard fournies par Java.

Création d’une exception personnalisée

Pour créer une exception personnalisée, il faut dériver une classe de Exception et définir deux constructeurs :

• Un constructeur sans paramètre
• Un constructeur prenant un message String

Exemple :

public class EmployeException extends Exception {
  public EmployeException() {
    super();
  }
  public EmployeException(String message) {
    super(message);
    System.out.println("Vous essayez d'instancier un Employe avec un age négatif !");
  }
}

Utilisation de throw et throws

• throws : indique qu’une méthode peut potentiellement lancer une exception, et signale à la JVM qu’elle doit être gérée ou propagée.
• throw : permet de lancer manuellement une exception en instanciant un objet de type Exception ou une sous-classe.

Exemple d’une classe Employe qui lance une exception personnalisée :

public class Employe {
  private int age;

  public Employe(int age) throws EmployeException {
    if (age < 0)
      throw new EmployeException();
    else
      this.age = age;
  }

  public void affiche() {
    System.out.println("age : " + age);
  }
}

Remarques importantes

• Le bloc try et ses blocs catch associés doivent être contigus. Un catch ne peut pas être séparé du try par d’autres instructions.
• Il est possible d’avoir plusieurs blocs catch pour un même try, mais ils doivent être ordonnés du plus spécifique au plus général.
• La classe Throwable fournit des méthodes utiles :
• getMessage() : retourne le message d’erreur associé à l’exception.
• printStackTrace() : affiche la pile des appels qui ont conduit à l’exception, utile pour le débogage.
• Le bloc finally est généralement utilisé pour effectuer des opérations de nettoyage, comme fermer des fichiers ou libérer des ressources.
• Le bloc finally s’exécute toujours, sauf si le programme appelle explicitement System.exit().

Glossaire des termes clés

• Exception : événement signalant une erreur ou une situation anormale lors de l’exécution d’un programme.
• Throwable : classe de base de toutes les erreurs et exceptions en Java.
• Error : sous-classe de Throwable, représentant des erreurs graves liées à la machine virtuelle.
• Exception checked : exceptions que le compilateur oblige à gérer ou déclarer avec throws.
• Exception unchecked : exceptions d’exécution non vérifiées, comme RuntimeException, qui ne nécessitent pas de déclaration throws.
• try : bloc de code dans lequel une exception peut survenir.
• catch : bloc qui intercepte et traite une exception spécifique.
• finally : bloc exécuté systématiquement après un try, pour effectuer des opérations de nettoyage.
• throw : instruction qui lance une exception manuellement.
• throws : déclaration indiquant qu’une méthode peut lancer une exception.
• Exception personnalisée : classe d’exception créée par le programmeur pour répondre à des besoins spécifiques.

Points clés à retenir

• Les exceptions permettent de séparer la détection d’une anomalie de son traitement, améliorant la lisibilité du code.
• Le mécanisme d’exception repose sur la levée, l’interruption et la capture des erreurs.
• Les exceptions Java sont classées en checked et unchecked, avec des règles différentes de gestion.
• Le bloc try/catch permet de gérer localement les exceptions, tandis que throws transmet l’exception.
• Le bloc finally garantit l’exécution d’instructions de nettoyage, quelles que soient les circonstances.
• Il est possible et souvent recommandé de créer ses propres exceptions pour mieux contrôler le comportement des programmes.
• Respecter la syntaxe et l’ordre des blocs try et catch est essentiel pour un code correct et lisible.