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 est construit sur une hiérarchie de classes bien organisée enracinée dans 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 pas les intercepter)
└── Exception      // Problèmes récupérables
    └── RuntimeException  // Exceptions non contrôlées

Error 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 vous travaillerez 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

Parce que les exceptions sont des classes, elles suivent les règles d'héritage. Lorsque vous interceptez un type d'exception parent, vous interceptez également tous ses enfants :

try {
    // du code
} catch (Exception e) {
    // Intercepte TOUTES les exceptions (généralement trop large)
}

try {
    // du code
} catch (RuntimeException e) {
    // Intercepte uniquement les exceptions d'exécution et les sous-classes
}

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 le fondement de la création de vos propres exceptions personnalisées.

Défi

Facile

Construisons un analyseur d'exceptions qui démontre comment la hiérarchie des exceptions en Java fonctionne en pratique ! Vous allez créer un système qui capture les exceptions à différents niveaux de spécificité et indique quel type a été capturé.

Vous organiserez votre code sur trois fichiers :

ExceptionThrower.java : Créez une classe capable de déclencher différents types d'exceptions en fonction de l'entrée. Votre classe doit avoir trois méthodes statiques :
triggerRuntime(String type) - En fonction de la chaîne type, lancez différentes exceptions d'exécution (runtime exceptions) :
- Si type est "null", lancez une NullPointerException avec le message "Null value encountered"
- Si type est "index", lancez une ArrayIndexOutOfBoundsException avec le message "Invalid index"
- Si type est "argument", lancez une IllegalArgumentException avec le message "Bad argument"
triggerArithmetic() - Lancez une ArithmeticException avec le message "Division error"

triggerGeneric() - Lancez une RuntimeException avec le message "Generic runtime error"
ExceptionAnalyzer.java : Créez une classe qui capture les exceptions à différents niveaux de la hiérarchie et identifie ce qui a été capturé. Incluez ces méthodes statiques :
analyzeSpecific(String type) - Appelez ExceptionThrower.triggerRuntime(type) à l'intérieur d'un bloc try. Utilisez des blocs catch séparés pour NullPointerException, ArrayIndexOutOfBoundsException, et IllegalArgumentException. Pour chacun, affichez : Caught specific: [exception class simple name] suivi de Message: [exception message]

analyzeWithParent() - Appelez ExceptionThrower.triggerArithmetic() à l'intérieur d'un bloc try. Capturez-la en utilisant RuntimeException (le type parent). Affichez : Caught via parent: RuntimeException suivi de Actual type: [exception class simple name]

analyzeWithGrandparent() - Appelez ExceptionThrower.triggerGeneric() à l'intérieur d'un bloc try. Capturez-la en utilisant Exception (encore plus haut dans la hiérarchie). Affichez : Caught via grandparent: Exception suivi de Actual type: [exception class simple name]
Main.java : Rassemblez votre analyseur d'exceptions ! Vous recevrez une entrée : une chaîne de type d'exception (soit "null", "index", ou "argument").
Tout d'abord, affichez === Specific Catch === et appelez analyzeSpecific avec votre entrée.

Ensuite, affichez une ligne vide, === Parent Catch ===, et appelez analyzeWithParent.

Enfin, affichez une ligne vide, === Grandparent Catch ===, et 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 la classe de l'exception et e.getMessage() pour récupérer son message. Ce défi montre comment la capture d'un type d'exception parent capture également tous ses enfants — un concept clé pour décider de la précision de votre gestion des exceptions !

Aide-mémoire

La gestion des exceptions en Java repose sur une hiérarchie de classes dont la racine est Throwable :

Throwable
├── Error          // Problèmes graves (ne pas intercepter)
└── Exception      // Problèmes récupérables
    └── RuntimeException  // Exceptions non contrôlées

Error représente des problèmes graves de la JVM comme OutOfMemoryError ou StackOverflowError que les applications ne devraient pas gérer.

Exception se divise en exceptions contrôlées (sous-classes directes) et exceptions non contrôlées (sous-classes de RuntimeException) :

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

Intercepter un type d'exception parent intercepte également tous ses enfants :

try {
    // du code
} catch (Exception e) {
    // Intercepte TOUTES les exceptions
}

try {
    // du code
} catch (RuntimeException e) {
    // Intercepte uniquement les exceptions d'exécution et leurs sous-classes
}

Utilisez e.getClass().getSimpleName() pour obtenir le nom de la classe de l'exception et e.getMessage() pour récupérer son message.

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: Afficher "=== Specific Catch ===" et appeler ExceptionAnalyzer.analyzeSpecific(type)
        
        // TODO: Afficher une ligne vide, puis "=== Parent Catch ===", puis appeler ExceptionAnalyzer.analyzeWithParent()
        
        // TODO: Afficher une ligne vide, puis "=== Grandparent Catch ===", puis appeler ExceptionAnalyzer.analyzeWithGrandparent()
    }
}