Les exceptions sont des événements qui interrompent l'exécution normale d'un programme. Cette section explique ce qu'est une exception et la différence entre les exceptions vérifiées et non vérifiées.

9.1Concepts essentiels

9.1.1 – Définition d'une exception

Une exception est un événement qui interrompt l'exécution normale d'un programme. Elle représente une erreur ou une situation exceptionnelle qui se produit pendant l'exécution. Java fournit un mécanisme robuste pour gérer ces exceptions.

🔍 Qu'est-ce qu'une exception ?

Une exception est un objet qui représente une erreur. Quand une exception se produit, Java crée un objet exception et le "lance" (throw). Si l'exception n'est pas capturée, le programme s'arrête.

Exemple : Exceptions courantes

// ArrayIndexOutOfBoundsException : index hors limites
int[] nombres = new int[5];
int valeur = nombres[10];  // ❌ Exception : index 10 n'existe pas (tableau de taille 5)

// NullPointerException : tentative d'utiliser null
String texte = null;
int longueur = texte.length();  // ❌ Exception : texte est null

// ArithmeticException : division par zéro
int resultat = 10 / 0;  // ❌ Exception : division par zéro

// NumberFormatException : conversion invalide
int nombre = Integer.parseInt("abc");  // ❌ Exception : "abc" n'est pas un nombre

📊 Hiérarchie des exceptions

Toutes les exceptions en Java héritent de la classe Throwable :

Throwable : Classe racine
Error : Erreurs système graves (rarement gérées)
Exception : Exceptions normales (gérées)

RuntimeException : Exceptions non vérifiées
Autres Exception : Exceptions vérifiées

💡 Pourquoi gérer les exceptions ?

La gestion des exceptions permet de :

Éviter les crashes : Empêcher le programme de s'arrêter brutalement
Informer l'utilisateur : Afficher des messages d'erreur compréhensibles
Récupérer : Permettre au programme de continuer après une erreur
Nettoyer : Libérer les ressources même en cas d'erreur

9.1.2 – Exceptions vérifiées et non vérifiées

Java distingue deux types d'exceptions : les exceptions vérifiées (checked) et les exceptions non vérifiées (unchecked). Cette distinction affecte la façon dont elles doivent être gérées.

✅ Exceptions vérifiées (Checked Exceptions)

Les exceptions vérifiées sont des exceptions que le compilateur force à être gérées. Elles héritent de Exception mais pas de RuntimeException.

Obligation : Doivent être gérées avec try/catch ou déclarées avec throws
Détection : Le compilateur vérifie qu'elles sont gérées
Exemples : IOException, FileNotFoundException, SQLException

Exemple : Exception vérifiée

import java.io.FileReader;
import java.io.IOException;

// ❌ ERREUR de compilation si non gérée
// FileReader reader = new FileReader("fichier.txt");

// ✅ CORRECT : Gestion avec try/catch
try {
    FileReader reader = new FileReader("fichier.txt");
} catch (IOException e) {
    System.out.println("Erreur : " + e.getMessage());
}

// ✅ CORRECT : Déclaration avec throws
public void lireFichier() throws IOException {
    FileReader reader = new FileReader("fichier.txt");
}

⚠️ Exceptions non vérifiées (Unchecked Exceptions)

Les exceptions non vérifiées sont des exceptions qui ne sont pas vérifiées par le compilateur. Elles héritent de RuntimeException.

Pas d'obligation : Ne doivent pas nécessairement être gérées
Détection : Le compilateur ne vérifie pas leur gestion
Exemples : NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException

Exemple : Exception non vérifiée

// Pas d'erreur de compilation, mais peut lever une exception à l'exécution
String texte = null;
int longueur = texte.length();  // NullPointerException à l'exécution

// Gestion optionnelle
try {
    int resultat = 10 / 0;  // ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Division par zéro !");
}

📊 Tableau de comparaison détaillé

Caractéristique	Exceptions vérifiées	Exceptions non vérifiées
Héritage	Exception (mais pas RuntimeException)	RuntimeException
Vérification	À la compilation	À l'exécution
Gestion obligatoire	Oui (try/catch ou throws)	Non (optionnelle)
Cas d'usage	Erreurs récupérables (fichiers, réseau)	Erreurs de programmation (bugs)
Exemples	IOException, SQLException	NullPointerException, ArrayIndexOutOfBoundsException

💡 Quand utiliser chaque type ?

Exceptions vérifiées : Pour des erreurs que le programmeur peut raisonnablement prévoir et gérer (fichier manquant, connexion réseau, etc.)
Exceptions non vérifiées : Pour des erreurs de programmation (bugs) qui indiquent un problème dans le code (null pointer, index invalide, etc.)

💡 Points clés à retenir

Exception vérifiée : Doit être gérée (try/catch ou throws)
Exception non vérifiée : Gestion optionnelle
RuntimeException : Toutes les exceptions non vérifiées en héritent
Compilateur : Vérifie seulement les exceptions vérifiées
Bonne pratique : Gérer les exceptions vérifiées, corriger les bugs pour les non vérifiées