La gestion des exceptions en Java constitue un mécanisme fondamental pour assurer la robustesse des applications. Les exceptions représentent des événements imprévus survenant durent l'exécution d'un programme. Sans une gestion adéquate, ces exceptions peuvent provoquer l'arrêt brutal de l'application.

Système d'exceptions

Le système d'exceptions en Java repose sur une structure hiérarchique où toutes les exceptions dérivent de la classe java.lang.Throwable.

Structure hiérarchique des exceptions

Throwable (classe racine, parente de toutes les exceptions et erreurs)
├─ Error (erreurs) : erreurs système JVM que le programme ne peut traiter
└─ Exception (exceptions) : exceptions que le programme peut capturer et traiter
   ├─ Checked Exception (exceptions contrôlées) : doivent être traitées à la compilation
   └─ Unchecked Exception (exceptions non contrôlées) : héritées de RuntimeException, non obligatoires à gérer

Classification détaillée des exceptions

1. Erreur (Error) - non traitables par le programme
   • Erreurs graves du JVM nécessitant l'arrêt du programme :
     • OutOfMemoryError : erreur de dépassement de mémoire
     • StackOverflowError : erreur de dépassement de pile
     • NoClassDefFoundError : classe introuvable lors du chargement
2. Exception contrôlée (Checked Exception) - traitement obligatoire à la compilation
   • Doivent être capturées via try-catch ou déclarées avec throws :
     • IOException : exceptions d'opérations d'entrée/sortie
     • FileNotFoundException : exception de fichier introuvable (sous-classe de IOException)
     • SQLException : exceptions liées aux opérations sur base de données
     • ClassNotFoundException : classe introuvable lors du chargement
     • InterruptedException : exception d'interruption de thread
3. Exception non contrôlée (Unchecked Exception) - traitement optionnel à la compilation
   • Héritées de RuntimeException, généralement dues à des erreurs logicielles :
     • NullPointerException (NPE) : tentative d'accès à un objet null
     • ArrayIndexOutOfBoundsException : indice de tableau hors limites
     • ClassCastException : conversion de type invalide
     • ArithmeticException : erreur arithmétique (ex: division par zéro)
     • IllegalArgumentException : paramètre invalide
     • IndexOutOfBoundsException : indice hors limites dans collections/chaînes

Gestion des exceptions

Java propose cinq mots-clés pour la gestion des exceptions : try, catch, finally, throw, throws.

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

public class GestionnaireExceptions {
    public static void main(String[] parametres) {
        // Bloc try-catch-finally pour capturer les exceptions
        try {
            // Opération susceptible de générer une exception
            int resultat = 20 / 0; 
        } catch (ArithmeticException e) {
            // Capture et traitement d'une exception arithmétique spécifique
            System.out.println("Exception arithmétique détectée: " + e.getMessage());
        } finally {
            // Bloc exécuté dans tous les cas
            // Utilisé pour la libération de ressources
            System.out.println("Ressources libérées");
        }
        
        // 1. Exception non contrôlée - référence null
        String donnee = null;
        try {
            System.out.println(donnee.length()); // Déclenche NullPointerException
        } catch (NullPointerException e) {
            System.out.println("Exception de pointeur null: " + e.getMessage());
        }

        // 2. Exception non contrôlée - opération arithmétique
        try {
            int numerateur = 15;
            int denominateur = 0;
            int valeur = numerateur / denominateur; // Déclenche ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Erreur mathématique: " + e.getMessage());
        }

        // 3. Exception contrôlée - lecture de fichier
        Document fichier = new Document("donnees.txt");
        try (LecteurFichier lf = new LecteurFichier(fichier)) { 
            // Lecture du contenu
        } catch (IOException e) { 
            // Capture des exceptions liées aux fichiers
            System.out.println("Erreur de lecture: " + e.getMessage());
        }
    }
}

Exceptions personnalisées

Lorsque les exceptions intégrées de Java ne répondent pas aux besoins spécifiques d'une application, il est possible de créer des exceptions personnalisées.

// Exception contrôlée personnalisée (hérite de Exception)
class ErreurMetierException extends Exception {
    public ErreurMetierException(String message) {
        super(message); // Appel du constructeur parent
    }
}

// Exception non contrôlée personnalisée (hérite de RuntimeException)
class ErreurTechniqueException extends RuntimeException {
    public ErreurTechniqueException(String message) {
        super(message);
    }
}

// Utilisation des exceptions personnalisées
public class DemonstrationExceptionPerso {
    public static void main(String[] args) throws ErreurMetierException {
        // Lancement d'une exception contrôlée personnalisée
        throw new ErreurMetierException("Situation métier anormale détectée");
        
        // Lancement d'une exception non contrôlée personnalisée
        // throw new ErreurTechniqueException("Problème technique survenu");
    }
}