Hiérarchie des classes d'exception

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 59 sur 87.

Le système de gestion des exceptions de Java repose sur une hiérarchie de classes bien organisée, dont la racine est la classe Throwable. Comprendre cette hiérarchie vous aide à intercepter et à gérer les exceptions plus efficacement.

Au sommet se trouve Throwable, le parent de toutes les exceptions et erreurs. Il possède deux sous-classes directes :

Throwable
├── Error          // Problèmes graves (ne les attrapez pas)
└── Exception      // Problèmes récupérables
    └── RuntimeException  // Exceptions non vérifiées

Une erreur représente des problèmes graves que les applications ne devraient pas essayer de gérer, comme OutOfMemoryError ou StackOverflowError. Ceux-ci indiquent des problèmes fondamentaux avec la JVM elle-même.

Exception est la branche avec laquelle tu travailleras le plus. Elle se divise en deux catégories : les exceptions contrôlées (sous-classes directes de Exception) et les exceptions non contrôlées (sous-classes de RuntimeException).

// Classes d'exception courantes
Exception
├── IOException           // Problèmes de fichier/réseau
├── SQLException          // Problèmes de base de données
└── RuntimeException
    ├── NullPointerException
    ├── ArrayIndexOutOfBoundsException
    └── IllegalArgumentException

Puisque les exceptions sont des classes, elles suivent les règles d’héritage. Lorsque vous appliquez catch à un type d’exception parent, vous interceptez également tous ses enfants :

try {
    // du code
} catch (Exception e) {
    // Capture TOUTES les exceptions (trop large en général)
}

try {
    // du code
} catch (RuntimeException e) {
    // Catches only runtime exceptions and subclasses
}

Cette hiérarchie vous permet d’être aussi précis ou général que nécessaire lors de la gestion des erreurs, et elle constitue la base de la création de vos propres exceptions personnalisées.

Défi

Facile

Construisons un analyseur d’exceptions qui montre concrètement comment fonctionne la hiérarchie des exceptions de Java ! Vous allez créer un système qui intercepte les exceptions à différents niveaux de spécificité et indique quel type a été intercepté.

Vous allez organiser votre code dans trois fichiers :

ExceptionThrower.java : créez une classe capable de déclencher différents types d’exceptions selon l’entrée. Votre classe doit comporter trois méthodes statiques :
triggerRuntime(String type) - Selon la chaîne de caractères type, déclenchez différentes exceptions d’exécution :
- Si type vaut "null", déclenchez une NullPointerException avec le message "Null value encountered"
- Si type vaut "index", déclenchez une ArrayIndexOutOfBoundsException avec le message "Invalid index"
- Si type vaut "argument", déclenchez une IllegalArgumentException avec le message "Bad argument"
triggerArithmetic() - Déclenchez une ArithmeticException avec le message "Division error"

triggerGeneric() - Déclenchez une IllegalStateException avec le message "Generic runtime error" (sa hiérarchie est Exception > RuntimeException > IllegalStateException)
ExceptionAnalyzer.java : créez une classe qui intercepte les exceptions à différents niveaux de la hiérarchie et identifie ce qui a été intercepté. Incluez ces méthodes statiques :
analyzeSpecific(String type) - Appelez ExceptionThrower.triggerRuntime(type) dans un bloc try. Utilisez des blocs catch distincts pour NullPointerException, ArrayIndexOutOfBoundsException et IllegalArgumentException. Pour chacun, affichez : Caught specific: [exception class simple name], suivi de Message: [exception message]

analyzeWithParent() - Appelez ExceptionThrower.triggerArithmetic() dans un bloc try. Interceptez-la avec RuntimeException (le type parent). Affichez : Caught via parent: RuntimeException, suivi de Actual type: [exception class simple name]

analyzeWithGrandparent() - Appelez ExceptionThrower.triggerGeneric() dans un bloc try. Interceptez-la avec Exception (encore plus haut dans la hiérarchie). Affichez : Caught via grandparent: Exception, suivi de Actual type: [exception class simple name]
Main.java : assemblez votre analyseur d’exceptions ! Vous recevrez une entrée : une chaîne indiquant le type d’exception (soit "null", "index" ou "argument").
Commencez par afficher === Specific Catch === et appelez analyzeSpecific avec votre entrée.

Affichez ensuite une ligne vide, === Parent Catch ===, puis appelez analyzeWithParent.

Enfin, affichez une ligne vide, === Grandparent Catch ===, puis appelez analyzeWithGrandparent.

Vous recevrez une entrée : le type d’exception à déclencher ("null", "index" ou "argument").

Utilisez e.getClass().getSimpleName() pour obtenir le nom de classe de l’exception et e.getMessage() pour récupérer son message. Ce défi montre qu’intercepter un type d’exception parent intercepte également tous ses types enfants : un concept essentiel pour déterminer le niveau de spécificité de la gestion de vos exceptions !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String type = scanner.nextLine();
        
        // TODO: Print "=== Specific Catch ===" and call ExceptionAnalyzer.analyzeSpecific(type)
        
        // TODO: Affiche une ligne vide, puis "=== Parent Catch ===", puis appelle ExceptionAnalyzer.analyzeWithParent()
        
        // TODO: Print a blank line, then "=== Grandparent Catch ===", then call ExceptionAnalyzer.analyzeWithGrandparent()
    }
}