Java fournit des mécanismes pour gérer les exceptions : try/catch pour capturer les exceptions et finally pour exécuter du code quoi qu'il arrive.

9.2Mécanismes de gestion

9.2.1 – try / catch

Le mécanisme try/catch permet de capturer et gérer les exceptions. Le bloc try contient le code qui peut lever une exception, et le bloc catch contient le code de gestion de l'exception.

🔑 Structure de base

Exemple : try/catch simple

try {
    // Code qui peut lever une exception
    int resultat = 10 / 0;  // Peut lever ArithmeticException
} catch (ArithmeticException e) {
    // Code de gestion de l'exception
    System.out.println("Erreur : " + e.getMessage());
    System.out.println("Division par zéro impossible !");
}

// Le programme continue après le catch
System.out.println("Programme continue...");

📝 Plusieurs blocs catch

Vous pouvez avoir plusieurs blocs catch pour gérer différents types d'exceptions.

Exemple : Plusieurs catch

try {
    int[] nombres = new int[5];
    int valeur = nombres[10];  // Peut lever ArrayIndexOutOfBoundsException
    int resultat = 10 / 0;      // Peut lever ArithmeticException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index hors limites : " + e.getMessage());
} catch (ArithmeticException e) {
    System.out.println("Erreur arithmétique : " + e.getMessage());
} catch (Exception e) {
    // Catch générique pour toutes les autres exceptions
    System.out.println("Erreur inconnue : " + e.getMessage());
}

Important : Placez les blocs catch du plus spécifique au plus général. Le catch générique (Exception) doit être en dernier.

🔍 Informations sur l'exception

L'objet exception fournit plusieurs méthodes utiles pour obtenir des informations sur l'erreur.

Exemple : Méthodes de l'exception

try {
    int resultat = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Message : " + e.getMessage());
    System.out.println("Type : " + e.getClass().getName());
    e.printStackTrace();  // Affiche la pile d'appels complète
}

🔄 Propagation d'exceptions (throws)

Au lieu de gérer une exception, vous pouvez la propager à la méthode appelante avec throws.

Exemple : Propagation avec throws

import java.io.FileReader;
import java.io.IOException;

// Méthode qui propage l'exception
public void lireFichier() throws IOException {
    FileReader reader = new FileReader("fichier.txt");
    // L'exception est propagée à l'appelant
}

// L'appelant doit gérer l'exception
public void utiliserFichier() {
    try {
        lireFichier();
    } catch (IOException e) {
        System.out.println("Erreur de lecture : " + e.getMessage());
    }
}

9.2.2 – finally

Le bloc finally s'exécute toujours, qu'une exception soit levée ou non. Il est utilisé pour le nettoyage de ressources (fermeture de fichiers, connexions, etc.).

🔑 Structure try/catch/finally

Exemple : Bloc finally

try {
    // Code qui peut lever une exception
    int resultat = 10 / 2;
    System.out.println("Résultat : " + resultat);
} catch (ArithmeticException e) {
    // Gestion de l'exception
    System.out.println("Erreur : " + e.getMessage());
} finally {
    // Code qui s'exécute TOUJOURS
    System.out.println("Nettoyage effectué");
}

// Affiche :
// Résultat : 5
// Nettoyage effectué

💡 Cas d'usage : Nettoyage de ressources

Le bloc finally est particulièrement utile pour garantir la fermeture de ressources, même en cas d'exception.

Exemple : Fermeture de fichier dans finally

import java.io.FileReader;
import java.io.IOException;

FileReader reader = null;
try {
    reader = new FileReader("fichier.txt");
    // Lecture du fichier...
} catch (IOException e) {
    System.out.println("Erreur : " + e.getMessage());
} finally {
    // Fermeture garantie, même en cas d'exception
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            System.out.println("Erreur de fermeture : " + e.getMessage());
        }
    }
}

🆕 try-with-resources (Java 7+)

Depuis Java 7, vous pouvez utiliser try-with-resources pour gérer automatiquement la fermeture des ressources.

Exemple : try-with-resources

import java.io.FileReader;
import java.io.IOException;

// try-with-resources : fermeture automatique
try (FileReader reader = new FileReader("fichier.txt")) {
    // Lecture du fichier...
    // reader.close() est appelé automatiquement
} catch (IOException e) {
    System.out.println("Erreur : " + e.getMessage());
}
// Pas besoin de finally : la ressource est fermée automatiquement

📊 Ordre d'exécution

L'ordre d'exécution est toujours :

Bloc try
Bloc catch (si exception levée)
Bloc finally (toujours)

Exemple : Ordre d'exécution

try {
    System.out.println("1. Dans try");
    int resultat = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("2. Dans catch");
} finally {
    System.out.println("3. Dans finally (toujours)");
}

// Affiche :
// 1. Dans try
// 2. Dans catch
// 3. Dans finally (toujours)

💡 Points clés à retenir

try : Contient le code qui peut lever une exception
catch : Gère l'exception levée
finally : S'exécute toujours, pour le nettoyage
Plusieurs catch : Du plus spécifique au plus général
throws : Pour propager une exception
try-with-resources : Fermeture automatique des ressources (Java 7+)

Conseils pratiques :

Utilisez finally pour garantir le nettoyage des ressources
Préférez try-with-resources pour les ressources (Java 7+)
Placez les catch du plus spécifique au plus général
Ne laissez jamais un bloc catch vide : au minimum, loggez l'erreur
Le bloc finally est exécuté même si un return est dans le try ou catch