Java throw vs throws : maîtriser la gestion d'exceptions avec exemples pratiques
Java throw vs throws : maîtriser la gestion d'exceptions avec exemples pratiques
Ce guide explique comment utiliser les mots-clés throw et throws de Java pour une gestion d'exceptions efficace, illustrés avec des exemples de code réels.
En Java, les exceptions se divisent en deux catégories :
- Exceptions non-vérifiées – non vérifiées à la compilation mais à l'exécution. Exemples :
ArithmeticException,NullPointerException,ArrayIndexOutOfBoundsException, et toutes les sous-classes deError. - Exceptions vérifiées – imposées par le compilateur. Exemples :
IOException,InterruptedException, et bien d'autres.
Pour une plongée plus profonde, voir Exceptions Java.
Les exceptions non-vérifiées signalent généralement des erreurs de programmation ; elles devraient être corrigées plutôt qu'attrapées. Les exceptions vérifiées, d'autre part, représentent des conditions que les appelants doivent connaître et gérer.
Utilisation du mot-clé throws
La clause throws déclare qu'une méthode peut lancer une ou plusieurs exceptions, déléguant la responsabilité aux appelants. Sa syntaxe est :
accessModifier returnType methodName() throws ExceptionType1, ExceptionType2 { /* code */ }
Vous pouvez lister plusieurs types d'exceptions, séparés par des virgules.
Exemple 1 : Déclaration d'une exception vérifiée
import java.io.*; class Main { public static void findFile() throws IOException { // Code qui peut déclencher IOException File newFile = new File("test.txt"); FileInputStream stream = new FileInputStream(newFile); } public static void main(String[] args) { try { findFile(); } catch (IOException e) { System.out.println(e); } } }
Sortie
java.io.FileNotFoundException: test.txt (No such file or directory)
Si test.txt est manquant, FileInputStream lance une FileNotFoundException, qui est une sous-classe de IOException. Parce que findFile() déclare throws IOException, la méthode main() doit la gérer ou la propager.
Lancer plusieurs exceptions
Vous pouvez déclarer plusieurs types d'exceptions dans une seule clause throws :
import java.io.*; class Main { public static void findFile() throws NullPointerException, IOException, InvalidClassException { // Potentiellement lance NullPointerException … // Potentiellement lance IOException … // Potentiellement lance InvalidClassException … } public static void main(String[] args) { try { findFile(); } catch (IOException e1) { System.out.println(e1.getMessage()); } catch (InvalidClassException e2) { System.out.println(e2.getMessage()); } } }
Remarquez que NullPointerException est non-vérifiée, donc elle n'a pas besoin d'être attrapée ou déclarée par l'appelant.
Quand utiliser throws vs try...catch
Intégrer try...catch dans chaque méthode qui pourrait lancer une exception peut encombrer le code et obscurcir la logique. Déclarer throws garde la signature de méthode propre et permet au code de niveau supérieur de décider comment gérer les erreurs.
Utilisation du mot-clé throw
L'instruction throw lance explicitement une instance d'exception, transférant le contrôle au bloc catch correspondant le plus proche ou terminant le programme si non gérée.
Syntaxe :
throw throwableObject;
Ici, throwableObject est une instance de Throwable ou de l'une de ses sous-classes.
Exemple 2 : Lancer une exception non-vérifiée
class Main { public static void divideByZero() { throw new ArithmeticException("Trying to divide by 0"); } public static void main(String[] args) { divideByZero(); } }
Sortie
Exception in thread "main" java.lang.ArithmeticException: Trying to divide by 0 at Main.divideByZero(Main.java:3) at Main.main(Main.java:7) exit status 1
Puisque ArithmeticException est non-vérifiée, l'attraper est optionnel.
Exemple 3 : Lancer une exception vérifiée
import java.io.*; class Main { public static void findFile() throws IOException { throw new IOException("File not found"); } public static void main(String[] args) { try { findFile(); System.out.println("Rest of code in try block"); } catch (IOException e) { System.out.println(e.getMessage()); } } }
Sortie
File not found
Ici, findFile() lance une IOException vérifiée, donc les appelants doivent soit la gérer, soit la déclarer. La méthode main() démontre l'attrapage de l'exception, prévenant la terminaison du programme.
Java
- Variables et littéraux en Java : Guide complet
- Maîtriser l'entrée/sortie Java : Afficher, lire et formater vos données
- Comprendre les expressions, instructions et blocs en Java
- Classes et objets en Java : Guide pratique
- Classes et méthodes abstraites en Java : guide complet
- Maîtriser les classes imbriquées et internes en Java : types, exemples et bonnes pratiques
- Maîtriser la gestion multi-exceptions en Java
- Maîtriser l'autoboxing et l'unboxing Java : Exemples pratiques et bonnes pratiques
- Maîtriser le remplacement de chaînes Java : replace(), replaceAll() et replaceFirst() expliqués