Parlez du mécanisme d'exceptions en Java.

En Java, le mécanisme d'exception est utilisé pour gérer les erreurs et autres situations exceptionnelles qui surviennent lors de l'exécution du programme.

Les éléments principaux du mécanisme d'exception :

• Exception (Exception) : Objet représentant un événement qui interrompt le flux normal d'exécution du programme.
• Blocs try, catch, finally : Utilisés pour gérer les exceptions.
  • try : Bloc de code où une exception peut survenir.
  • catch : Bloc de code qui s'exécute si une exception d'un type spécifique survient dans le bloc try.
  • finally : Bloc de code qui s'exécute toujours, indépendamment de la survenue ou non d'une exception. Utilisé pour libérer des ressources.
• Mot-clé throw : Utilisé pour créer et lancer explicitement une exception.
• Mot-clé throws : Utilisé dans la signature de la méthode pour déclarer les types d'exceptions que la méthode peut lancer.

Hiérarchie des exceptions en Java :

• Throwable : Classe de base pour toutes les exceptions et erreurs.
  • Error : Représente des problèmes graves dont le programme ne peut généralement pas se remettre (par exemple, OutOfMemoryError).
  • Exception : Représente des exceptions que le programme peut intercepter et gérer.
    • RuntimeException (Exceptions non vérifiées) : Exceptions qui ne nécessitent pas de gestion ou de déclaration explicite dans la signature de la méthode (par exemple, NullPointerException, ArrayIndexOutOfBoundsException).
    • Exceptions vérifiées (Checked Exceptions) : Exceptions qui doivent être soit gérées avec un bloc try-catch, soit déclarées avec throws dans la signature de la méthode (par exemple, IOException, FileNotFoundException).

Exemple de gestion d'exception :

public class ExceptionExample {

    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Résultat : " + result);
        } catch (ArithmeticException e) {
            // Gestion de l'exception ArithmeticException
            System.err.println("Erreur : division par zéro non autorisée.");
            System.err.println("Détails de l'exception : " + e.getMessage());
            e.printStackTrace(); // Affiche la pile d'appels
        } finally {
            // Ce bloc s'exécutera toujours
            System.out.println("Bloc finally exécuté.");
        }
    }

    public static int divide(int a, int b) {
        // Peut lancer ArithmeticException si b = 0
        return a / b;
    }
}

Exemple d'utilisation de throws :

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

public class ThrowsExample {

    public static void readFile(String filename) throws IOException {
        // Peut lancer IOException
        FileReader reader = new FileReader(filename);
        // Travail supplémentaire avec le fichier
    }

    public static void main(String[] args) {
        try {
            readFile("fichier_inexistant.txt");
        } catch (IOException e) {
            System.err.println("Erreur lors de la lecture du fichier : " + e.getMessage());
        }
    }
}