Exceptions cochées et non cochées en Java

1. Vue d'ensemble

Les exceptions Java se répartissent en deux catégories principales: les exceptions cochées et les exceptions non cochées . Dans cet article, nous fournirons quelques exemples de code sur la façon de les utiliser.

2. Exceptions vérifiées

En général, les exceptions vérifiées représentent des erreurs hors du contrôle du programme. Par exemple, le constructeur de FileInputStream lève FileNotFoundException si le fichier d'entrée n'existe pas.

Java vérifie les exceptions vérifiées au moment de la compilation.

Nous devrions donc utiliser le throws mot - clé pour déclarer une exception vérifiée:

private static void checkedExceptionWithThrows() throws FileNotFoundException { File file = new File("not_existing_file.txt"); FileInputStream stream = new FileInputStream(file); }

Nous pouvons également utiliser un bloc try-catch pour gérer une exception vérifiée:

private static void checkedExceptionWithTryCatch() { File file = new File("not_existing_file.txt"); try { FileInputStream stream = new FileInputStream(file); } catch (FileNotFoundException e) { e.printStackTrace(); } }

Certaines exceptions vérifiées courantes dans Java sont IOException , SQLException et ParseException .

La classe Exception est la superclasse des exceptions vérifiées. Par conséquent, nous pouvons créer une exception vérifiée personnalisée en étendant Exception :

public class IncorrectFileNameException extends Exception { public IncorrectFileNameException(String errorMessage) { super(errorMessage); } } 

3. Exceptions non vérifiées

Si un programme lève une exception non vérifiée, il reflète une erreur dans la logique du programme. Par exemple, si nous divisons un nombre par 0, Java lancera ArithmeticException :

private static void divideByZero() { int numerator = 1; int denominator = 0; int result = numerator / denominator; } 

Java ne vérifie pas les exceptions non vérifiées au moment de la compilation. Furtheremore, nous ne devons pas déclarer des exceptions non contrôlées dans une méthode avec le throws mot - clé. Et bien que le code ci-dessus n'ait aucune erreur lors de la compilation, il lancera ArithmeticException au moment de l'exécution.

Certaines exceptions non vérifiées courantes en Java sont NullPointerException , ArrayIndexOutOfBoundsException et IllegalArgumentException .

La classe RuntimeException est la superclasse de toutes les exceptions non vérifiées . Par conséquent, nous pouvons créer une exception non contrôlée personnalisée en étendant RuntimeException :

public class NullOrEmptyException extends RuntimeException { public NullOrEmptyException(String errorMessage) { super(errorMessage); } }

4. Quand utiliser les exceptions cochées et les exceptions non cochées

Il est recommandé d'utiliser des exceptions en Java afin de pouvoir séparer le code de gestion des erreurs du code normal. Cependant, nous devons décider du type d'exception à lever. La documentation Oracle Java fournit des conseils sur l'utilisation des exceptions vérifiées et des exceptions non vérifiées:

«Si l'on peut raisonnablement s'attendre à ce qu'un client récupère d'une exception, faites-en une exception cochée. Si un client ne peut rien faire pour récupérer de l'exception, faites-en une exception non cochée. »

Par exemple, avant d'ouvrir un fichier, nous pouvons d'abord valider le nom du fichier d'entrée. Si le nom du fichier d'entrée de l'utilisateur n'est pas valide, nous pouvons lancer une exception vérifiée personnalisée:

if (!isCorrectFileName(fileName)) { throw new IncorrectFileNameException("Incorrect filename : " + fileName ); } 

De cette façon, nous pouvons récupérer le système en acceptant un autre nom de fichier d'entrée utilisateur. Cependant, si le nom du fichier d'entrée est un pointeur nul ou une chaîne vide, cela signifie que nous avons des erreurs dans le code. Dans ce cas, nous devrions lever une exception non vérifiée:

if (fileName == null || fileName.isEmpty()) { throw new NullOrEmptyException("The filename is null or empty."); } 

5. Conclusion

Dans cet article, nous avons discuté de la différence entre les exceptions cochées et non cochées. Nous avons également fourni des exemples de code pour montrer quand utiliser des exceptions cochées ou non cochées.

Comme toujours, tout le code trouvé dans cet article se trouve à l'adresse over sur GitHub.