Module Java.9 – Exceptions

Objectif

Maîtriser la gestion des exceptions Java : checked/unchecked, try/catch/finally, et exceptions personnalisées pour créer des applications robustes.

Théorie

Types d'exceptions

Checked Exceptions

Doivent être déclarées ou gérées (compilateur vérifie).

Exemples :

• IOException : Erreurs d'entrée/sortie
• SQLException : Erreurs base de données
• FileNotFoundException : Fichier introuvable

Gestion obligatoire :

public void lireFichier() throws IOException {
    // Code qui peut lancer IOException
}

// Ou avec try/catch
public void lireFichier() {
    try {
        // Code
    } catch (IOException e) {
        // Gestion
    }
}

Unchecked Exceptions

Runtime exceptions, pas obligatoires à gérer.

Exemples :

• NullPointerException : Référence null
• ArrayIndexOutOfBoundsException : Index invalide
• ArithmeticException : Division par zéro
• IllegalArgumentException : Argument invalide

Pas obligatoire :

public void diviser(int a, int b) {
    int resultat = a / b;  // Peut lancer ArithmeticException
    // Pas besoin de try/catch ou throws
}

try/catch/finally

Structure de base

try {
    // Code qui peut générer une exception
    int resultat = diviser(10, 0);
} catch (ArithmeticException e) {
    // Gestion spécifique
    System.out.println("Division par zéro");
} catch (Exception e) {
    // Gestion générale
    System.out.println("Erreur : " + e.getMessage());
} finally {
    // Code toujours exécuté
    System.out.println("Nettoyage");
}

Plusieurs catch

L'ordre est important : du plus spécifique au plus général.

try {
    // Code
} catch (FileNotFoundException e) {
    // Spécifique
} catch (IOException e) {
    // Plus général
} catch (Exception e) {
    // Très général
}

finally

S'exécute toujours, même si exception lancée.

FileReader reader = null;
try {
    reader = new FileReader("fichier.txt");
    // Lecture
} catch (IOException e) {
    // Gestion
} finally {
    if (reader != null) {
        try {
            reader.close();  // Toujours fermer
        } catch (IOException e) {
            // Gestion
        }
    }
}

try-with-resources (Java 7+) :

try (FileReader reader = new FileReader("fichier.txt")) {
    // Lecture
    // Fermeture automatique
} catch (IOException e) {
    // Gestion
}

Lancer des exceptions

throw

Lancer une exception.

public int diviser(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("Division par zéro impossible");
    }
    return a / b;
}

throws

Déclarer qu'une méthode peut lancer une exception.

public void lireFichier() throws IOException {
    // Code qui peut lancer IOException
}

Exceptions personnalisées

Créer ses propres types d'exceptions.

Checked exception personnalisée

class ValidationException extends Exception {
    private String champ;
    
    public ValidationException(String message, String champ) {
        super(message);
        this.champ = champ;
    }
    
    public String getChamp() {
        return champ;
    }
}

Unchecked exception personnalisée

class AgeInvalideException extends RuntimeException {
    private int age;
    
    public AgeInvalideException(String message, int age) {
        super(message);
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }
}

Utilisation

public void validerAge(int age) throws ValidationException {
    if (age < 0) {
        throw new ValidationException("Age négatif", "age");
    }
    if (age > 150) {
        throw new ValidationException("Age invalide", "age");
    }
}

// Ou unchecked
public void setAge(int age) {
    if (age < 0 || age > 150) {
        throw new AgeInvalideException("Age invalide : " + age, age);
    }
    this.age = age;
}

Propriétés des exceptions

catch (Exception e) {
    e.getMessage();        // Message d'erreur
    e.getCause();          // Cause de l'exception
    e.printStackTrace();   // Affiche la pile d'appels
    e.getClass().getName(); // Nom de la classe
}

Bonnes pratiques

1. Toujours gérer les checked exceptions

// ❌ Mauvais
public void lireFichier() {
    FileReader reader = new FileReader("fichier.txt");
}

// ✅ Bon
public void lireFichier() {
    try {
        FileReader reader = new FileReader("fichier.txt");
    } catch (FileNotFoundException e) {
        // Gestion
    }
}

2. Messages d'erreur clairs

// ❌ Mauvais
throw new Exception("Erreur");

// ✅ Bon
throw new ValidationException("L'email doit être valide", "email");

3. Logging approprié

catch (Exception e) {
    // Log pour développeur
    System.err.println("Erreur technique : " + e.getMessage());
    e.printStackTrace();
    
    // Message utilisateur clair
    System.out.println("Une erreur s'est produite");
}

4. Ne pas capturer Exception générique

// ❌ Mauvais : trop général
catch (Exception e) {
    // Cache tous les problèmes
}

// ✅ Bon : spécifique
catch (FileNotFoundException e) {
    // Gestion spécifique
} catch (IOException e) {
    // Gestion IO
}

Exercice

1. try/catch

   • Créez du code qui génère des exceptions
   • Capturez-les avec try/catch
   • Testez finally

2. Checked vs Unchecked

   • Créez des méthodes avec checked exceptions
   • Testez la gestion obligatoire
   • Comparez avec unchecked

3. Exceptions personnalisées

   • Créez des exceptions personnalisées
   • Lancez-les dans votre code
   • Gérez-les spécifiquement

4. try-with-resources

   • Utilisez try-with-resources
   • Comparez avec finally manuel
   • Testez la fermeture automatique

5. Bonnes pratiques

   • Appliquez les bonnes pratiques
   • Loggez correctement
   • Messages clairs

Quiz

1. Quelle est la différence entre checked et unchecked ?

   • Aucune différence
   • Checked doit être gérée, unchecked non
   • Unchecked est plus grave

2. Quand s'exécute finally ?

   • Seulement en cas d'erreur
   • Toujours
   • Seulement en cas de succès

3. Que fait try-with-resources ?

   • Gère les exceptions
   • Ferme automatiquement les ressources
   • Optimise le code

4. Comment créer une exception personnalisée ?

   • new Exception()
   • Créer une classe qui étend Exception
   • throw "message"

5. Que signifie throws ?

   • Lance une exception
   • Déclare qu'une méthode peut lancer une exception
   • Gère une exception

Mini défi

Mission : Créer un système de validation robuste

Créez un système complet de validation avec gestion d'erreurs :

Fonctionnalités :

1. Exceptions personnalisées (ValidationException, FormatException)
2. Fonctions de validation (email, age, mot de passe)
3. Gestion complète avec try/catch
4. Logging approprié
5. Messages utilisateur clairs

Critères :

• ✅ Exceptions personnalisées créées
• ✅ Toutes les validations implémentées
• ✅ Gestion d'erreurs complète
• ✅ try-with-resources si applicable
• ✅ Code robuste

Objectif : Maîtriser les exceptions Java et créer un système robuste.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez checked/unchecked, try/catch/finally et exceptions personnalisées.