Mots-clés throw et throws Java

Dans ce tutoriel, nous allons apprendre à gérer les exceptions en utilisant les mots-clés throw et throws à l'aide d'exemples.

En Java, les exceptions peuvent être divisées en deux types :

• Exceptions non vérifiées :Elles ne sont pas vérifiées au moment de la compilation, mais à l'exécution, par exemple : ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, exceptions sous la catégorie Error, etc.

• Exceptions à vérifier :Vérifiez-les lors de la compilation. Par exemple IOException, InterruptedException, etc.

Veuillez consulterExceptions JavaPour mieux comprendre les exceptions vérifiées et non vérifiées.

Généralement, nous n'avons pas besoin de traiter les exceptions non vérifiées. Cela est dû au fait que les exceptions non vérifiées se produisent généralement à cause d'erreurs de programmation. Et il est une bonne habitude de les corriger plutôt que de les traiter.

Maintenant, ce tutoriel se concentrera sur la manière d'utiliser throw et throws pour traiter les exceptions vérifiées.

Clé de mots throws Java

Nous utilisons la clé de mots throws dans la déclaration de méthode pour déclarer les types d'exceptions possibles.

Sa syntaxe est :

accessModifier returnType methodName() throws ExceptionType1, ExceptionType2　... {
　　//　code
}

À partir de la syntaxe ci-dessus, on voit que nous pouvons utiliser throws pour déclarer plusieurs exceptions.

Exemple1Clé de mots throws Java

import java.io.*;
class Main {
　　public static void findFile() throws IOException {
　　　　//Le code peut générer une exception 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);
　　　　}
　　}
}

Output result

java.io.FileNotFoundException: test.txt (Fichier ou répertoire introuvable)

Si la méthode ne traite pas les exceptions, il faut spécifier dans la clause throws les types d'exceptions possibles qui peuvent se produire dans cette méthode, afin que les méthodes de plus haut niveau dans la pile d'appel puissent les traiter ou les spécifier elles-mêmes en utilisant la clé de mots throws.

La méthode findFile() spécifie qu'elle peut lancer une IOException. La méthode main() appelle cette méthode et traite les exceptions lancées.

Lever plusieurs exceptions

Voici comment nous utilisons la clé de mots throws pour lever plusieurs exceptions.

import java.io.*;
class Main {
　　public static void findFile() throws NullPointerException, IOException, InvalidClassException {
　　　　
　　　　//　Le code peut générer une exception NullPointerException
　　　　… … …　
　　　　//　Le code peut générer une exception IOException
　　　　… … …　
　　　　//　Le code peut générer une exception InvalidClassException　
　　　　… … …　
　　}
　　public static void main(String[] args) {
　　　　try{
　　　　　　findFile();
　　　　}1{
　　　　　　System.out.println(e1.getMessage());
　　　　}2{
　　　　　　System.out.println(e2.getMessage());
　　　　}
　　}
}

Ici, la méthode findFile() spécifie qu'elle peut lever NullPointerException, IOException et InvalidClassException dans sa clause throws.

Veuillez noter que nous n'avons pas traité NullPointerException. C'est parce qu'il s'agit d'une exception non contrôlée. Il n'est pas nécessaire de le spécifier dans la clause throws et de le traiter.

Clé de commande throws avec try...catch...finally

Il peut y avoir plusieurs méthodes qui peuvent entraîner des exceptions. Écrire try...catch pour chaque méthode serait ennuyeux et le code deviendrait long et difficile à comprendre.

Lorsque vous avez vérifié les exceptions que vous ne souhaitez pas capturer dans la méthode actuelle (les exceptions que vous devez traiter), throws est également utile.

Clé de commande Java throw

La clé de commande throw est utilisée pour lever explicitement une exception.

Lorsque l'exception est déclenchée, le flux d'exécution du programme passe du bloc try au bloc catch. Nous utilisons la clé de commande throw dans la méthode.

Sa syntaxe est :

lève throwableObject;

Un objet Throwable est un exemple de la classe Throwable ou d'une sous-classe de Throwable.

Exemple2Lève la clé de commande Java

class Main {
　　public static void divideByZero() {
　　　　lève new ArithmeticException("Division par zéro");
　　}
　　public static void main(String[] args) {
　　　　divideByZero();
　　}
}

Output result

Exception dans le thread "main" java.lang.ArithmeticException: Division par zéro
　　　　at Main.divideByZero(Main.java:3)
　　　　at Main.main(Main.java:7)
état de sortie　1

Dans cet exemple, nous levons explicitement ArithmeticException.

Remarque : ArithmeticException est une exception non contrôlée. Il n'est généralement pas nécessaire de traiter les exceptions non contrôlées.

Exemple3Lève une exception de contrôle

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("The remaining code in the try block");
　　　　} catch (IOException e) {
　　　　　　System.out.println(e.getMessage());
　　　　}
　　}
}

Output result

File not found

The findFile() method throws an IOException by passing a message to its constructor.

Note that since it is a checked exception, it must be specified in the throws clause.

The method that calls findFile() needs to handle this exception, or specify it using the throws keyword itself.

We have handled this exception in the main() method. When an exception is thrown, the program execution flow transfers between the try blocks to catch. Therefore, the remaining code in the try block will be skipped, and the statements in the catch block will be executed.