Erreurs Checked vs Unchecked

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

Vous avez vu que la hiérarchie des exceptions de Java se divise en différentes branches. La distinction essentielle que vous devez comprendre est celle entre les exceptions vérifiées et non vérifiées. Cela influe sur la manière dont vous devez les gérer dans votre code.

Les exceptions vérifiées sont des exceptions que le compilateur vous oblige à gérer. Elles étendent directement Exception (et non par l’intermédiaire de RuntimeException). Vous devez soit les intercepter, soit les déclarer avec throws :

// Doit gérer IOException - c'est une exception vérifiée
public void readFile(String path) throws IOException {
    FileReader reader = new FileReader(path);  // Peut lancer IOException
}

// Ou l'attraper
public void readFileSafe(String path) {
    try {
        FileReader reader = new FileReader(path);
    } catch (IOException e) {
        System.out.println("File error: " + e.getMessage());
    }
}

Les exceptions non vérifiées étendent RuntimeException. Le compilateur n’exige pas que vous les traitiez. Elles indiquent généralement des erreurs de programmation telles que des références nulles ou un accès à un tableau non valide :

// Aucune déclaration throws nécessaire
public int divide(int a, int b) {
    return a / b;  // Peut lever ArithmeticException (non vérifiée)
}

String name = null;
name.length();  // NullPointerException (non vérifiée)

Lorsque vous créez des exceptions personnalisées, choisissez la classe parente en fonction de la manière dont vous souhaitez que les appelants les gèrent. Utilisez des exceptions vérifiées pour les situations récupérables auxquelles l’appelant doit s’attendre. Utilisez des exceptions non vérifiées pour les erreurs de programmation qui ne devraient pas se produire dans un code correct.

Défi

Facile

Construisons un système de vérification d’âge qui illustre la différence essentielle entre les exceptions vérifiées et non vérifiées ! Vous allez créer des exceptions personnalisées des deux types et voir comment le compilateur les traite différemment.

Vous organiserez votre code sur quatre fichiers :

InvalidAgeException.java : créez une exception vérifiée pour les échecs de validation de l’âge. Cette exception doit étendre directement Exception, ce qui signifie que les appelants seront obligés de la gérer. Incluez un constructeur qui accepte un message et le transmet à la classe parente.
NegativeAgeException.java : créez une exception non vérifiée lorsqu’une personne fournit un âge négatif (une erreur de programmation qui ne devrait pas se produire avec une entrée correcte). Elle doit étendre RuntimeException. Incluez un constructeur qui accepte un message et le transmet à la classe parente.
AgeVerifier.java : créez une classe qui valide les âges à l’aide des deux types d’exceptions. Incluez deux méthodes statiques :
verifyAge(int age) - Cette méthode doit lever NegativeAgeException (non vérifiée) avec le message "Age cannot be negative: [age]" si l’âge est inférieur à 0. Si l’âge est inférieur à 18, levez InvalidAgeException (vérifiée) avec le message "Must be 18 or older: [age]". Sinon, affichez Age [age] verified successfully. Puisque cette méthode lève une exception vérifiée, vous devez la déclarer avec throws InvalidAgeException.

verifyAgeUncheckedOnly(int age) - Cette méthode utilise uniquement des exceptions non vérifiées. Si l’âge est négatif, levez NegativeAgeException avec le même format de message. Si l’âge est inférieur à 18, levez une IllegalArgumentException avec le message "Too young: [age]". Sinon, affichez Age [age] verified (unchecked method). Remarquez que cette méthode n’a besoin d’aucune déclaration throws !
Main.java : réunissez votre système de vérification ! Vous recevrez une entrée : un âge (entier).
Commencez par afficher === Checked Exception Method === et appelez verifyAge avec l’âge fourni. Puisqu’elle lève une exception vérifiée, vous devez l’encapsuler dans un bloc try-catch. Interceptez InvalidAgeException et affichez Checked exception caught: [message]. Interceptez également NegativeAgeException et affichez Unchecked exception caught: [message].

Affichez ensuite une ligne vide et === Unchecked Exception Method ===. Appelez verifyAgeUncheckedOnly avec le même âge. Même si cette méthode peut lever des exceptions, vous n’êtes pas obligé de les intercepter. Cependant, encapsulez-la tout de même dans un bloc try-catch afin de gérer les erreurs correctement. Interceptez NegativeAgeException et affichez Runtime exception caught: [message]. Interceptez IllegalArgumentException et affichez Illegal argument caught: [message].

Vous recevrez une entrée : un entier représentant l’âge à vérifier.

Remarquez la différence essentielle : la méthode avec l’exception vérifiée exige une déclaration throws et oblige les appelants à la gérer, tandis que la méthode avec l’exception non vérifiée se compile correctement sans aucune gestion d’exception. C’est la distinction fondamentale entre les exceptions vérifiées et non vérifiées en Java !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int age = scanner.nextInt();
        
        // TODO: Test the checked exception method
        // Print: "=== Checked Exception Method ==="
        // Appelez AgeVerifier.verifyAge(age) dans un try-catch
        // - Catch InvalidAgeException: print "Checked exception caught: [message]"
        // - Catch NegativeAgeException: print "Unchecked exception caught: [message]"
        
        
        // TODO: Print a blank line, then "=== Unchecked Exception Method ==="
        // Appelez AgeVerifier.verifyAgeUncheckedOnly(age) dans un try-catch
        // - Catch NegativeAgeException: print "Runtime exception caught: [message]"
        // - Catch IllegalArgumentException: print "Illegal argument caught: [message]"
        
    }
}