Fondamentaux des exceptions

En Java, une exception représente une anomalie qui survient durant l'exécution d'un programme, interrompant ainsi le flux normal des instructions. Prenons l'exemple suivant où l'on tente d'assigner une chaîne de caractères à un type primitif entier ; le compilateur rejettera cette instruction :

int nombre = "texte"; // Incompatibilité de type

Voici quelques erreurs classiques fréquemment rencontrées :

1. ArithmeticException

2. ArrayIndexOutOfBoundsException

int[] tableau = {10, 20, 30};
System.out.println(tableau[5]); // L'index 5 n'existe pas

3. NullPointerException

String chaine = null;
System.out.println(chaine.length()); // Appel sur une référence nulle

Hiérarchie des exceptions

L'architecture de gestion des erreurs en Java repose sur la classe Throwable, qui est la superclasse de toutes les erreurs et exceptions :

• Throwable : Point d'ancrage de toute la hiérarchie.
• Error : Représente des défaillances graves que la JVM ne peut pas récupérer, comme l'épuisement de la mémoire (OutOfMemoryError) ou le débordement de la pile d'appels (StackOverflowError).
• Exception : Désigne les anomalies que le développeur peut anticiper et corriger. C'est la catégorie que l'on manipule couramment.

Catégorisation : Vérifiées vs Non Vérifiées

Exceptions vérifiées (Checked Exceptions)

Ce sont des erreurs détectées lors de la compilation. Le programmeur est obligé de les traiter explicitement avant que le code ne puisse être compilé. Par exemple, tenter d'assigner un nombre à virgule flottante à une variable de type int sans cast explicite déclenchera une erreur de compilation que l'IDE signalera immédiatement.

Exceptions non vérifiées (Unchecked Exceptions)

Ces erreurs apparaissent à l'exécution et héritent de la classe RuntimeException. Le compilateur ne force pas leur traitement. NullPointerException, ArrayIndexOutOfBoundsException et ArithmeticException en sont des exemples typiques.

Stratégies de gestion des anomalies

Lorsqu'une anomalie est identifiée, deux philosophies s'offrent au développeur :

1. Approche défensive (LYBL - Look Before You Leap)

Cette méthode consiste à vérifier rigoureusement les conditions avant d'exécuter une action.

boolean statut = false;
statut = initialiserConnexion();
if (!statut) {
    System.out.println("Échec de l'initialisation !");
    return;
}
statut = validerUtilisateur();
if (!statut) {
    System.out.println("Utilisateur invalide !");
    return;
}
statut = verifierMotDePasse();
if (!statut) {
    System.out.println("Mot de passe incorrect !");
    return;
}

Bien que fonctionnelle, cette approche entremêle la logique métier valide avec la logique de gestion des erreurs, rendant le code difficile à lire et à maintenir.

2. Approche par la tolérance aux fautes (EAFP - Easier to Ask Forgiveness than Permission)

Ici, on exécute l'action directement et on intercepte l'erreur si elle survient. Java implémente cette philosophie via les blocs try-catch.

try {
    initialiserConnexion();
    validerUtilisateur();
    verifierMotDePasse();
} catch (ErreurInitialisation e) {
    traiterErreurInitialisation();
} catch (ErreurUtilisateur e) {
    traiterErreurUtilisateur();
} catch (ErreurMotDePasse e) {
    traiterErreurMotDePasse();
}

Cette séparation nette entre le flux nominal et le flux d'erreur améliore considérablement la lisibilité. Les cinq mots-clés essentiels pour la gestion des exceptions en Java sont : throw, throws, try, catch et finally.

Lever une exception manuellement

Le mot-clé throw permet de déclencher explicitement une exception depuis le corps d'une méthode.

public class Validateur {
    public static void verifierTableau(int[] donnees) {
        if (donnees == null) {
            throw new NullPointerException("Le tableau de données est nul");
        }
    }
    public static void main(String[] args) {
        verifierTableau(null);
    }
}

Règles importantes concernant throw :

• Il doit impérativement se trouver à l'intérieur d'un bloc de méthode.
• L'objet jeté doit obligatoirement être de type Throwable ou l'une de ses sous-classes.
• Si l'exception levée est de type RuntimeException (ou sous-classe), elle n'a pas besoin d'être déclarée ou interceptée explicitement ; la JVM s'en chargera.
• Si c'est une exception vérifiée, elle doit être interceptée ou déclarée avec throws, sinon la compilation échoue.
• Une fois une exception levée via throw, le code qui suit immédiatement l'instruction ne sera jamais exécuté.

Capturer et traiter les exceptions

Il existe deux manières principales de gérer les exceptions : la déclaration (throws) et l'interception (try-catch).

Déclaration avec throws

Lorsqu'une méthode ne souhaite pas gérer elle-même une exception vérifiée, elle peut la déclarer dans sa signature à l'aide de throws. Cela transfère la responsabilité de traitement à la méthode appelante.

// Syntaxe
public void traitementFichier(String chemin) throws IOException, FileNotFoundException {
    // Logique susceptible de échouer
}

Si la méthode appelante ne gère toujours pas l'exception, elle sera finalement transmise à la JVM, ce qui provoquera l'arrêt brutal du programme.

Interception avec try-catch

Le bloc try enveloppe le code susceptible de générer une erreur. Le bloc catch définit le type d'exception à intercepter et l'action à entreprendre.

public class Application {
    public static void main(String[] args) {
        try {
            int resultat = 10 / 0;
        } catch (ArithmeticException e) {
            System.err.println("Division par zéro interceptée !");
            e.printStackTrace(); // Affiche la trace de la pile pour le débogage
        }
    }
}

Si aucun catch ne correspond au type d'exception levée, celle-ci remonte vers la JVM et le programme s'arrête.

Créer des exceptions personnalisées

Java permet de définir ses propres classes d'exception pour répondre à des besoins métier spécifiques. Hériter de Exception crée une exception vérifiée (obligeant le compilateur à exiger un traitement), tandis qu'hériter de RuntimeException crée une exception non vérifiée.

Voici un exemple implémentant un système d'authentification avec des exceptions métier sur mesure :

public class IdentifiantInvalideException extends RuntimeException {
    public IdentifiantInvalideException() {}
    public IdentifiantInvalideException(String message) {
        super(message);
    }
}

public class MotDePasseInvalideException extends RuntimeException {
    public MotDePasseInvalideException() {}
    public MotDePasseInvalideException(String message) {
        super(message);
    }
}

public class ServiceAuthentification {
    private final String identifiantRef = "admin_sys";
    private final String motDePasseRef = "ultra_secret";

    public void connecter(String identifiant, String motDePasse) {
        if (!this.identifiantRef.equals(identifiant)) {
            throw new IdentifiantInvalideException("L'identifiant fourni est incorrect");
        }
        if (!this.motDePasseRef.equals(motDePasse)) {
            throw new MotDePasseInvalideException("Le mot de passe ne correspond pas");
        }
        System.out.println("Authentification réussie.");
    }
}

public class SystemePrincipal {
    public static void main(String[] args) {
        try {
            ServiceAuthentification auth = new ServiceAuthentification();
            auth.connecter("user_lambda", "12345");
        } catch (IdentifiantInvalideException e) {
            e.printStackTrace();
            System.out.println("Traitement de l'erreur d'identifiant.");
        } catch (MotDePasseInvalideException e) {
            e.printStackTrace();
            System.out.println("Traitement de l'erreur de mot de passe.");
        }
    }
}