Objectifs de la Gestion des Exceptions

• Anticiper les erreurs : Identifier les scénarios d’erreur potentiels.
• Détecter les erreurs : Implémenter des mécanismes pour capturer les erreurs lorsqu’elles se produisent.
• Réagir aux erreurs : Définir comment le programme doit répondre à différents types d’erreurs.

Défis

• Lisibilité : Mélanger le code de test avec le code de l’application rend la lecture difficile.
• Maintenabilité : Difficile de maintenir le code de gestion des erreurs.
• Responsabilité : Incertitude sur qui doit gérer l’erreur, l’appelant ou l’appelé.

La classe Exception

• Définition : La classe Exception est la classe de base pour toutes les exceptions en Java.

  • Les exceptions sont des objets qui encapsulent des informations sur les erreurs.

• Constructeurs :

  • Exception(String message): Construit une nouvelle exception avec le message détaillé spécifié.
  • Exception(String message, Throwable cause): Construit une nouvelle exception avec le message détaillé spécifié et la cause.
    • La “cause” est éventuellement une autre exception qui a conduit à l’exception actuelle.
    • Cela permet de chaîner les exceptions pour mieux comprendre la séquence d’erreurs qui a conduit à un problème.

• Exceptions prédéfinies : IllegalArgumentException, NullPointerException, ArrayIndexOutOfBoundsException, etc.

• Méthodes :

  • String getMessage(): Retourne le message détaillé de l’exception.
  • Throwable getCause(): Retourne la cause de l’exception.

• printstacktrace() : Affiche la trace de la pile

Types d’Exceptions

• Exceptions vérifiées (Checked Exceptions) :
  • Vérifiées à la compilation.
  • Héritent de Exception (mais pas de RuntimeException) qui hérite de Throwable.
  • Doivent être gérées ou déclarées dans la signature de la méthode avec throws.
  • Exemple : IOException, SQLException
• Exceptions non vérifiées (Unchecked Exceptions) :
  • Vérifiées à l’exécution.
  • Héritent de RuntimeException (qui hérite de Exception).
  • Exemple : NullPointerException, ArrayIndexOutOfBoundsException
• Erreurs (Errors) :
  • Problèmes sérieux qu’une application ne devrait pas essayer de capturer.
  • Héritent de Error qui hérite de Throwable.
  • Exemple : OutOfMemoryError, StackOverflowError

Exemple avec l’ouverture d’un fichier

import java.util.logging.Logger;

Logger logger = Logger.getLogger("Notebook");

import java.io.*;

try (BufferedReader reader = new BufferedReader(new FileReader("/etc/issue.net"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (FileNotFoundException e) {
    logger.severe("Erreur de fichier non trouvé %s".formatted(e.getMessage()));
} catch (IOException e) {
    logger.severe("Erreur de lecture du fichier %s".formatted(e.getMessage()));
}

Ubuntu 24.04.1 LTS

Autoclôture des Ressources

• Java 7 a introduit le concept d’autoclôture des ressources pour simplifier la gestion des ressources.
• Les ressources qui implantent l’interface AutoCloseable peuvent être utilisées dans un bloc try-with-resources.
• Les ressources sont automatiquement fermées à la fin du bloc try.
• Pas besoin de bloc finally pour fermer les ressources.

Exemple avec l’ouverture d’un fichier

public class MyDataException extends Exception {
    public MyDataException(String message, Throwable cause) {
        super(message, cause);
    }
}

public void readIssueFile(String filepath) throws MyDataException {
    try (BufferedReader reader = new BufferedReader(new FileReader(filepath))) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    } catch (FileNotFoundException e) {
        throw new MyDataException("Erreur de fichier non trouvé", e);
    } catch (IOException e) {
        throw new MyDataException("Erreur de lecture du fichier", e);
    }
}

Ubuntu 24.04.1 LTS

Exemple d’Enveloppement d’Exception

    public class CauseException extends Exception {
        public CauseException(String message) {
            super(message);
        }
    }
    
    public void method2() throws CauseException {
        throw new CauseException("Erreur dans method2");
    }
    
    public class CustomException extends Exception {
        public CustomException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    public void method1() throws CustomException {
        try {
            method2();
        } catch (CauseException e) {
            throw new CustomException("Erreur enveloppée dans method1", e);
        }
    }

    public void test() {
        try {
            method1();
        } catch (CustomException e) {
            System.err.println("Exception capturée : " + e.getMessage());
            e.printStackTrace();
        }
    }

    test();

Exception capturée : Erreur enveloppée dans method1
REPL.$JShell$78C$CustomException: Erreur enveloppée dans method1
    at REPL.$JShell$97C.method1($JShell$97C.java:58)
    at REPL.$JShell$94B.test($JShell$94B.java:56)
    at REPL.$JShell$99.do_it$($JShell$99.java:54)
    at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
    at java.base/java.lang.reflect.Method.invoke(Method.java:580)
    at io.github.spencerpark.ijava.execution.IJavaExecutionControl.lambda$execute$1(IJavaExecutionControl.java:95)
    at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:317)
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144)
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:642)
    at java.base/java.lang.Thread.run(Thread.java:1583)
Caused by: REPL.$JShell$95D$CauseException: Erreur dans method2
    at REPL.$JShell$96C.method2($JShell$96C.java:55)
    at REPL.$JShell$97C.method1($JShell$97C.java:56)
    ... 9 more

Avantages de la Propagation des Exceptions

• Séparation des préoccupations : Permet de séparer le code de gestion des erreurs du code de logique métier.
• Réutilisabilité : Facilite la réutilisation des méthodes sans avoir à dupliquer le code de gestion des erreurs.
• Lisibilité : Améliore la lisibilité du code en réduisant le nombre de blocs try-catch imbriqués.

Exemple d’utilisation

• Vérification d’une condition simple :

  int age = -1;
  assert age >= 0 : "L'âge ne peut pas être négatif : " + age;
  System.out.println("L'âge est : " + age);

• Par défaut, les assertions sont désactivées à l’exécution.

• Pour les activer, utilisez l’option -ea (ou -enableassertions) lors de l’exécution du programme :

  java -ea AssertionExample

Meilleures Pratiques

• Utiliser des exceptions spécifiques : Capturer des exceptions spécifiques plutôt qu’une exception générique.
• Éviter de masquer les exceptions : Ne pas capturer une exception sans la gérer.
• Journaliser les exceptions : Toujours journaliser les exceptions pour le débogage.
• Nettoyer les ressources : Utiliser le bloc finally ou try-with-resources pour nettoyer les ressources.
• Documenter les exceptions : Utiliser Javadoc pour documenter les exceptions qu’une méthode peut lancer.

Exemple 2 : Exception Personnalisée

public class AgeValidator {
    public void validateAge(int age) throws InvalidAgeException {
        if (age < 0 || age > 150) {
            throw new InvalidAgeException("Âge invalide : " + age);
        }
    }
}

public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

Exemple 3 : Utilisation de try-with-resources

import java.sql.*;

    public void connectToDatabase() {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "root";
        String password = "password";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement()) {
            ResultSet rs = stmt.executeQuery("SELECT * FROM mytable");
            while (rs.next()) {
                System.out.println(rs.getString("column1"));
            }
        } catch (SQLException e) {
            System.err.println("Erreur de base de données : " + e.getMessage());
        }
    }