Comment gérer les erreurs en Java et comment y travailler?

En Java, les erreurs sont gérées à l'aide du mécanisme d'exceptions. Les exceptions représentent des événements qui interrompent le déroulement normal de l'exécution du programme. Il existe deux types d'exceptions : les Exceptions Vérifiées (Checked Exceptions) et les Exceptions Non Vérifiées (Unchecked Exceptions).

Exceptions Vérifiées :

• Héritent de java.lang.Exception (sauf RuntimeException).
• Doivent être gérées (avec try-catch) ou déclarées dans la signature de la méthode (avec throws).
• Représentent des erreurs pouvant survenir dans des conditions normales (par exemple, IOException, FileNotFoundException).

Exceptions Non Vérifiées :

• Héritent de java.lang.RuntimeException ou java.lang.Error.
• Ne nécessitent pas de gestion ou déclaration obligatoire.
• Représentent des erreurs qui indiquent souvent des erreurs logiques dans le code ou des états anormaux de l'environnement d'exécution (par exemple, NullPointerException, ArrayIndexOutOfBoundsException).

Gestion des exceptions :

Pour gérer les exceptions, on utilise des blocs try-catch-finally :

• try : Bloc de code susceptible de générer une exception.
• catch : Bloc de code qui s'exécute si une exception du type spécifié se produit dans le try. Plusieurs blocs catch peuvent être utilisés pour différents types d'exceptions.
• finally : Bloc de code qui s'exécute indépendamment de la survenue ou non d'une exception. Souvent utilisé pour libérer des ressources (fermeture de fichiers, connexions, etc.).

try {
    // Code susceptible de lancer une exception
    int result = 10 / 0; // Exemple : ArithmeticException
} catch (ArithmeticException e) {
    // Gestion de ArithmeticException
    System.err.println("Erreur de division par zéro : " + e.getMessage());
    // Peut enregistrer l'erreur, afficher un message à l'utilisateur, etc.
} catch (Exception e) {
    // Gestion de toute autre exception si elle n'a pas été traitée précédemment
    System.err.println("Une erreur générale est survenue : " + e.getMessage());
} finally {
    // Code qui s'exécute toujours
    System.out.println("Bloc finally exécuté.");
}

Propagation des exceptions :

Une méthode peut déclarer qu'elle peut générer une exception spécifique en utilisant le mot-clé throws :

public void readFile(String filePath) throws FileNotFoundException, IOException {
    // Code pour lire un fichier
    // Si le fichier n'est pas trouvé, une FileNotFoundException (sous-classe de IOException) peut être levée
    FileReader fr = new FileReader(filePath);
    // Si une erreur d'entrée/sortie se produit, une IOException peut être levée
    // ...
}

La méthode appelante doit gérer cette exception (try-catch) ou la déclarer également avec throws.

Création de ses propres exceptions :

Il est possible de créer des classes d'exceptions personnalisées héritant de Exception (pour les Exceptions Vérifiées) ou RuntimeException (pour les Exceptions Non Vérifiées).

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

Utilisation :

public void processData(int value) throws MyCustomException {
    if (value < 0) {
        throw new MyCustomException("La valeur ne peut pas être négative");
    }
    // Traitement des données
}

Principales classes d'exceptions (hiérarchie) :

• java.lang.Throwable (classe de base pour toutes les erreurs et exceptions)
  • java.lang.Error (pour des problèmes graves généralement non gérés par le programme, par exemple, OutOfMemoryError)
  • java.lang.Exception (pour les exceptions que le programme peut gérer)
    • java.lang.RuntimeException (Exceptions Non Vérifiées)
      • NullPointerException
      • ArrayIndexOutOfBoundsException
      • ArithmeticException
      • etc.
    • Autres sous-classes de Exception (Exceptions Vérifiées)
      • IOException
      • FileNotFoundException
      • SQLException
      • etc.

Travailler avec les erreurs implique de comprendre cette hiérarchie, de choisir le type d'exception approprié (lors de la création de ses propres), d'utiliser efficacement try-catch-finally pour gérer et propager les exceptions, et également de logger les erreurs pour le débogage.