Java try-catch : gérer les exceptions sans planter

Capturer une exception au lieu de planter

Vous savez déjà que lorsqu'un problème survient, Java lance une exception, et qu'une exception non gérée arrête votre programme avec une stack trace. Un bloc try-catch est votre façon de reprendre le contrôle : vous entourez le code risqué d'un try, et s'il lance une exception, Java saute au bloc catch correspondant au lieu de planter.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;          // lance ArithmeticException
            System.out.println(result);   // jamais atteint
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program keeps running");
    }
}

Au moment où 10 / 0 lance l'exception, le reste du bloc try est ignoré et le contrôle passe au catch. Une fois le catch terminé, l'exécution se poursuit normalement : le programme ne meurt pas.

La variable du catch contient l'exception

Le e dans catch (ArithmeticException e) est un véritable objet. Il porte des informations sur ce qui a mal tourné, le plus utile étant un message :

public class Main {
    public static void main(String[] args) {
        try {
            int n = Integer.parseInt("not a number");
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Bad input: " + e.getMessage());
        }
    }
}

e.getMessage() renvoie une courte description. Pendant le débogage, e.printStackTrace() affiche la trace complète montrant exactement d'où vient l'exception ; utilisez-le quand un message seul ne suffit pas à trouver la cause.

Capturez le type précis, pas tout

Un bloc catch ne capture que les exceptions qui correspondent à son type déclaré (ou à une sous-classe). La plus grande erreur de débutant est de capturer Exception pour faire « disparaître » un problème :

// Ne faites pas ça - cela cache de vrais bugs
try {
    doWork();
} catch (Exception e) {
    // avale NullPointerException, fautes de frappe, erreurs de logique... tout
}

Capturez le type le plus restreint que vous pouvez réellement gérer. Si vous attendez une saisie numérique invalide, capturez NumberFormatException. Tout ce que vous n'avez pas anticipé devrait pouvoir se propager pour que vous en soyez réellement informé au lieu de continuer silencieusement dans un état corrompu.

Gérer plusieurs types d'exceptions

Vous pouvez empiler plusieurs blocs catch. Java les vérifie de haut en bas et exécute le premier qui correspond ; ordonnez-les donc du plus précis au plus général :

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "oops", null};

        for (String s : inputs) {
            try {
                int n = Integer.parseInt(s);
                System.out.println("Parsed: " + n);
            } catch (NumberFormatException e) {
                System.out.println("Not a number: " + s);
            } catch (NullPointerException e) {
                System.out.println("Got a null value");
            }
        }
    }
}

Lorsque deux types partagent le même traitement, utilisez un seul multi-catch avec | plutôt que de dupliquer le bloc :

public class Main {
    public static void main(String[] args) {
        try {
            Object[] words = {"a", "b"};
            System.out.println(words[5]);   // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Bad access: " + e.getClass().getSimpleName());
        }
    }
}

Un piège : un type plus général doit venir après les types précis. Mettre catch (Exception e) en premier rend les blocs plus précis qui suivent inaccessibles, et le compilateur le refuse.

finally s'exécute toujours

Un bloc finally s'exécute après le try et tout catch, quoi qu'il se soit passé : succès, exception capturée ou même return anticipé. C'est là qu'appartient le nettoyage qui doit toujours avoir lieu.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // lance une exception
            System.out.println("Working");  // ignoré
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // s'exécute quoi qu'il arrive
        }
    }
}

« Closing resource » s'affiche que l'exception se déclenche ou non. Évitez toutefois de faire un return depuis l'intérieur d'un finally : cela peut discrètement écarter une exception ou remplacer une valeur renvoyée par le bloc try.

try-with-resources ferme les choses à votre place

Quand vous travaillez avec quelque chose qui doit être fermé - un fichier, une connexion réseau, une instruction de base de données - le déclarer à l'intérieur de try (...) le ferme automatiquement à la fin du bloc, même si une exception est lancée. Tout type qui implémente l'interface AutoCloseable fonctionne.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner implémente AutoCloseable, donc il se ferme automatiquement
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

Cela remplace l'ancien modèle qui consistait à ouvrir dans le try et fermer dans le finally, et c'est moins source d'erreurs car vous ne pouvez pas oublier de fermer. Préférez-le chaque fois que vous manipulez une ressource fermable.

N'utilisez pas les exceptions pour le flux de contrôle normal

try-catch est fait pour les situations exceptionnelles, pas pour les conditions ordinaires. Capturer une exception coûte plus cher qu'une simple vérification, et rend le code plus difficile à lire. Si vous pouvez tester la condition au préalable, faites-le :

// À éviter : utiliser un catch pour tester une clé manquante
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // gérer la clé manquante
}

// À préférer : vérifier explicitement
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

Réservez le catch aux choses qui échappent réellement à votre contrôle : saisie utilisateur invalide, fichiers manquants, pannes réseau.

Ensuite : NullPointerException

L'exception la plus courante que vous capturerez (et provoquerez) en Java est la NullPointerException : elle apparaît à l'instant où vous appelez une méthode sur quelque chose qui s'avère être null. Nous allons ensuite examiner précisément ce qui la déclenche, comment lire sa stack trace et les habitudes qui l'empêchent de se produire dès le départ.