Présentation des exceptions

Une exception représente un problème survenant lors de l'exécution d'un programme. Par exemple :

// Exception de dépassement d'indice de tableau
int[] nombres = {5, 15, 25};
System.out.println(nombres[4]); // Lève ArrayIndexOutOfBoundsException

// Exception arithmétique
int dividende = 12;
int diviseur = 0;
System.out.println(dividende / diviseur); // Lève ArithmeticException

Structure du système d'exceptions

Error : Représente des erreurs système critiques (problèmes graves) que les développeurs ne gèrent pas directement.
Exception : Désigne les exceptions potentielles du programme. On utilise généralement Exception et ses sous-classes pour encapsuler les problèmes.

Classification des exceptions

Exceptions d'exécution : RuntimeException et ses sous-classes. Elles ne génèrent pas d'avertisements lors de la compilation, mais apparaissent à l'exécution (par exemple, ArrayIndexOutOfBoundsException).
Exceptions de compilation : Elles déclenchent des avertissements pendant la compilation (par exemple, des erreurs de parsing de dates).

Question 1 : Quelle est la classe parente supérieure dans la hiérarchie des exceptions ? Combien de types d'exceptions existe-t-il ?
Réponse : La classe parente est Expection. Les exceptions se divisent en deux catégories : exceptions de compilation et exceptions d'exécution.

Question 2 : Quelle est la différence entre une exception de compilation et une exception d'exécution ?
Réponse : Les exceptions de compilation incluent toutes les classes sauf RuntimeException et ses sous-classes. Elles doivent être traitées pour alerter le développeur. Les exceptions d'exécution englobent RuntimeException et ses sous-classes, ne sont pas détectées à la compilation, et résultent souvent de paramètres incorrects.

Rôle des exceptions

1. Les exceptions fournissent des informations essentielles pour le débogage.
2. Elles peuvent servir de valeurs de retour spéciales dans les méthodes pour informer l'appelant de l'état d'exécution.

Méthodes de traitement des exceptions

1. Traitement par défaut de la JVM
2. Traitement manuel (capture d'exceptions)
3. Lancer des exceptions

1. Traitement par défaut de la JVM

La JVM affiche dans la console le nom de l'exception, sa cause et sa position. Le programme s'arrête, et le code suivant n'est pas exécuté.

2. Traitement manuel (capture d'exceptions)

Objectif : Permettre au programme de continuer son exécution même en cas d'exception.
Syntaxe :

try {
    // Code susceptible de lever une exception
} catch (TypeException variable) {
    // Code de traitement de l'exception
}

Exemple pratique :

int[] donnees = {10, 20, 30, 40, 50};
try {
    System.out.println(donnees[7]); // Lève ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException ex) {
    System.out.println("Indice hors limites");
}
System.out.println("Exécution continuée");

3. Lancer des exceptions

throws : Déclaré dans la signature de méthode pour informer l'appelant des exceptions possibles.
Syntaxe :

public void maMethode() throws ExceptionType1, ExceptionType2 {
    // Corps de la méthode
}
// Obligatoire pour les exceptions de compilation, optionnel pour les exceptions d'exécution.

throw : Utilisé dans le corps de méthode pour lancer manuellement une exception, interrompant l'exécution.
Syntaxe :

public void traitement() {
    throw new NullPointerException();
}

Scénarios courants :

Si aucune exception dans try : Tout le code de try s'exécute, le bloc catch est ignoré.

Si plusieurs exceptions possibles : Utiliser plusieurs blocs catch. Si les exceptions ont une relation parent-enfant, la classe parente doit être catchée en dernier. Depuis Java 7, on peut capturer plusieurs exceptions dans un seul catch avec le symbole |.

// Exemple en Java 7
int[] valeurs = {3, 6, 9};
try {
    System.out.println(valeurs[5]); // ArrayIndexOutOfBoundsException
    System.out.println(4 / 0);      // ArithmeticException
} catch (ArrayIndexOutOfBoundsException | ArithmeticException err) {
    System.out.println("Erreur d'indice ou arithmétique");
} catch (Exception e) {
    System.out.println("Autre exception");
}

Si une exception non capturée : Elle est gérée par la JVM par défaut.

Si une exception est capturée : Le code après l'exception dans try n'est pas exécuté, et l'exécution passe au bloc catch correspondant.

Méthodes de la classe Throwable

1. public String getMessage() : Retourne un message détaillé de l'erreur.
2. public String toString() : Fournit une description abrégée.
3. public void printStackTrace() : Affiche les informations d'erreur dans la console sans arrêter le programme.

Exceptions pesronnalisées

Pour améliorer la lisibilité des messages d'erreur :

1. Définir une classe d'exception.
2. Spécifier la relation d'héritage.
3. Implémenter des constructeurs (sans paramètre et avec paramètre).

Exemple :

public class InvalidLengthException extends RuntimeException {
    public InvalidLengthException() {
    }
    public InvalidLengthException(String message) {
        super(message);
    }
}

Utilisation dans une méthode :

public void setNom(String nom) {
    if (nom.length() < 3 || nom.length() > 10) {
        throw new InvalidLengthException("Longueur invalide : 3 à 10 caractères attendus");
    }
    this.nom = nom;
}

Intégration dans un programme :

Scanner saisie = new Scanner(System.in);
ObjetTest test = new ObjetTest();
while (true) {
    try {
        System.out.println("Entrez un nom valide");
        String input = saisie.nextLine();
        test.setNom(input);
        System.out.println("Entrez un âge valide");
        String ageStr = saisie.nextLine();
        int age = Integer.parseInt(ageStr);
        test.setAge(age);
        break;
    } catch (NumberFormatException ex) {
        ex.printStackTrace();
    } catch (InvalidLengthException ex) {
        ex.printStackTrace();
    }
}
System.out.println(test);