Gestion des exceptions Java

Dans ce tutoriel, vous allez apprendre à utiliser Java pour traiter les exceptions à l'aide d'exemples. Pour traiter les exceptions, nous utiliserons les blocks try...catch...finally.

Dans le tutoriel précédent, nous avons appris à connaître les exceptions. Les exceptions sont des événements imprévus qui se produisent pendant l'exécution du programme.

捕捉和处理异常

En Java, nous utilisons les composants de gestion des exceptions try, catch et finally pour traiter les exceptions.

Pour capturer et traiter les exceptions, nous plaçons le block de code try...catch...finally autour du code susceptible de générer des exceptions. Le block finally est optionnel.

La syntaxe de try...catch...finally est :

try {}}
　　//　code
} catch (ExceptionType e) {　
　　//　捕获块
}
　　//block finally
}

Java try ... catch块

Le code susceptible de générer des exceptions est placé dans le block try.

Un block try devrait être suivi d'un block catch ou finally. Lorsqu'une exception se produit, elle est capturée par le block suivant immédiatement après.

　Le block catch ne peut pas être utilisé seul, il doit suivre immédiatement le block try.

Exemple1：try ... catch块

class Main {
　　public static void main(String[] args) {
　　　　try {}}
　　　　　　int divideByZero =　5　/　0;
　　　　　　System.out.println("Le reste du code du block try");
　　　　} catch (ArithmeticException e) {
　　　　　　System.out.println("ArithmeticException => ");　+　e.getMessage());
　　　　}
　　}
}

Résultat de la sortie

ArithmeticException =>　/　par zéro

Dans cet exemple

• Nous divisons un nombre par zéro dans le block try. Cela génère une ArithmeticException.

• Lorsqu'une exception se produit, le programme saute le reste du code du block try.

• Dans ce qui suit, nous créons un block catch pour traiter ArithmeticException. Par conséquent, les instructions à l'intérieur du block catch sont exécutées.

Si toutes les instructions du block try ne génèrent pas d'exception, le block catch est sauté.

多个捕获块

Pour chaque block try, il peut y avoir zéro ou plusieurs blocks catch.

Le type de paramètre de chaque catch indique le type d'exception que l'on peut traiter. Plusieurs blocks catch nous permettent de traiter chaque exception de différentes manières.

Exemple2：多个捕获块

class ListOfNumbers {
　　public int[] arrayOfNumbers = new int[10];
　　public void writeList() {
　　　　try {}}
　　　　　　arrayOfNumbers[10] =　11;
　　　　} catch (NumberFormatException e1) {
　　　　　　System.out.println("NumberFormatException => "　+　e1.getMessage());
　　　　}2) {
　　　　　　System.out.println("IndexOutOfBoundsException => ");　+　e2.getMessage());
　　　　}
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　ListOfNumbers list = new ListOfNumbers();
　　　　list.writeList();
　　}
}

Résultat de la sortie

IndexOutOfBoundsException => Index　10　Hors des limites pour la longueur　10

Dans cet exemple, nous déclarons une taille de10 d'un tableau d'entiers arrayOfNumbers.}}

Nous savons que les indices d'array commencent toujours par 0. Par conséquent, lorsque nous essayons de donner l'indice10IndexOutOfBoundsException se produit lors de l'attribution d'une valeur, car les limites de l'array arrayOfNumbers sont de 0 à9.

Lorsque se produit une exception dans le bloc try

• L'exception est lancée vers le premier bloc catch. Le premier bloc catch ne traite pas l'exception IndexOutOfBoundsException, donc elle est transmise au bloc catch suivant.

• Le second bloc catch de l'exemple ci-dessus est le gestionnaire d'exceptions approprié, car il traite l'exception IndexOutOfBoundsException. Par conséquent, il est exécuté.

Bloc finally en Java

Pour chaque bloc try, il ne peut y avoir qu'un seul bloc finally.

Le bloc finally est optionnel. Mais s'il est défini, il sera toujours exécuté (même s'il n'y a pas d'exception).

S'il se produit une exception, elle est exécutée après le bloc try...catch. Si aucune exception ne se produit, elle est exécutée après le bloc try.

La syntaxe de base du bloc finally est :

try {}}
　　//code
} catch (ExceptionType1　e1) {　
　　//　bloc catch
} catch (ExceptionType1　e2) {
　//　bloc catch
}
　　//Le bloc finally s'exécute toujours
}

Exemple3Exemple de bloc finally

class Main {
　　public static void main(String[] args) {
　　　　try {}}
　　　　　　int divideByZero =　5　/　0;
　　　　} catch (ArithmeticException e) {
　　　　　　System.out.println("ArithmeticException => ");　+　e.getMessage());
　　　　}
　　　　　　System.out.println("Le bloc finally est toujours exécuté");
　　　　}
　　}
}

Résultat de la sortie

ArithmeticException =>　/　par zéro
Le bloc finally est toujours exécuté

Dans cet exemple, nous divisons un nombre par zéro. Cela provoque une ArithmeticException qui est capturée par le bloc catch, et le bloc finally est toujours exécuté.

L'utilisation du bloc finally est considérée comme une bonne pratique. C'est parce qu'il contient des codes de nettoyage importants, par exemple

• Code peut être sauté accidentellement par des instructions return, continue ou break

• Fermeture de fichiers ou de connexions

Nous avons mentionné que finally est toujours exécuté, généralement ainsi. Mais dans certains cas, le bloc finally ne s'exécute pas :

• Utilisation de la méthode System.exit()

• Une exception se produit dans le bloc finally

• Le thread est terminé

Exemple4Exemple de try, catch et finally

Laissons-nous prendre un exemple, nous essayons de créer un nouveau fichier à l'aide de FileWriter et d'écrire des données avec PrintWriter.

import java.io.*;
class ListOfNumbers {
　　private int[] list = new int[10];
　　public ListOfNumbers() {
　　　　//Stocker des valeurs entières dans l'array de la liste
　　　　for (int i = 0; i <　10; i++) {
　　　　　　list[i] = i;
　　　　}　	
　　}
}
　　public void writeList() {
　　　　PrintWriter out = null;
　　　　try {}}
　　　　　　System.out.println("Entrée dans l'instruction try");
　　　　　　//Créer un nouveau fichier OutputFile.txt
　　　　　　out = new PrintWriter(new FileWriter("OutputFile.txt"));
　　　　　　//Écrire les valeurs de l'array de liste dans le fichier créé récemment
　　　　　　for (int i = 0; i <　10; i++) {
　　　　　　　　out.println("Value at: ");　+　i　+　" = "　+　list[i];
　　　　　　}
　　　　}1) {
　　　　　　System.out.println("IndexOutOfBoundsException => ");　+　e1.getMessage());
　　　　}2) {
　　　　　　System.out.println("IOException => ");　+　e2.getMessage());
　　　　}
　　　　　　//Vérifiez si le PrintWriter est ouvert
　　　　　　if (out != null) {
　　　　　　　　System.out.println("Fermeture du PrintWriter");
　　　　　　　　out.close();
　　　　　　} else {
　　　　　　　　System.out.println("Le PrintWriter ne peut pas être ouvert");
　　　　　　}
　　　　}
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　ListOfNumbers list = new ListOfNumbers();
　　　　list.writeList();
　　}
}

Lorsque vous exécutez ce programme, deux possibilités peuvent se produire :

1. Une exception se produit dans le bloc try

2. Le bloc try s'exécute normalement

Des exceptions peuvent se produire lors de la création d'un nouveau FileWriter. Si le fichier spécifié ne peut pas être créé ou écrit, IOException est lancée.

Lorsqu'une exception se produit, nous obtenons les sorties suivantes.

Entrez dans l'instruction try
IOException => OutputFile.txt
PrintWriter ne peut pas être ouvert

Lorsque l'exception n'a pas été produite et que le bloc try s'exécute normalement, nous obtenons le résultat suivant.

Entrez dans l'instruction try
Fermez PrintWriter

Un fichier OutputFile.txt sera créé et contiendra le contenu suivant

Value at: 0 = 0
Value at:　1　=　1
Value at:　2　=　2
Value at:　3　=　3
Value at:　4　=　4
Value at:　5　=　5
Value at:　6　=　6
Value at:　7　=　7
Value at:　8　=　8
Value at:　9　=　9

Détail du flux try ... catch ... finally

Essayons de comprendre en détail le flux du traitement des exceptions avec l'aide de l'exemple ci-dessus.

L'image ci-dessus décrit le flux d'exécution du programme lors de l'exception lors de la création du nouveau FileWriter.

• Pour trouver la méthode où l'exception s'est produite, la méthode principale appelle la méthode writeList(), qui appelle ensuite la méthode FileWriter() pour créer un nouveau fichier OutputFile.txt.

• Lorsque se produit une exception, le système d'exécution en temps réel saute le reste du code dans le bloc try.

• Il commence à chercher dans l'ordre inverse la pile d'appels pour trouver le programmeur d'exceptions approprié.

• Ici, FileWriter n'a pas de programmeur d'exceptions, donc le système de temps d'exécution vérifie le prochain méthode dans la pile d'appels, c'est-à-dire writeList.

• La méthode writeList a deux programmeurs d'exceptions : un pour traiter l'IndexOutOfBoundsException et un autre pour traiter IOException.

• Ensuite, le système traite ces programmeurs l'un après l'autre.

• Dans cet exemple, le premier programmeur traite l'IndexOutOfBoundsException. Cela ne correspond pas à l'IOException déclenchée par le bloc try.

• Par conséquent, vérifiez quel est le prochain programmeur IOException. Si il correspond au type d'exception déclenchée, alors le code du bloc catch correspondant sera exécuté.

• Après l'exécution du programme de traitement des exceptions, le bloc finally sera exécuté.

• Dans cette situation, en raison de l'exception qui s'est produite dans FileWriter, l'objet PrintWriter out n'a jamais été ouvert, donc il n'est pas nécessaire de le fermer.

Maintenant, supposons que pendant l'exécution du programme, aucune exception n'ait été produite et que le bloc try s'exécute normalement. Dans ce cas, un fichier OutputFile.txt sera créé et écrit.

Il est bien connu que l'exécution du bloc finally n'a rien à voir avec le traitement des exceptions. Comme il n'y a pas eu d'exception, PrintWriter a été ouvert et doit être fermé. Cela est réalisé par la phrase out.close() dans le bloc finally.

Capturer plusieurs exceptions

À partir de Java SE 7À partir de la version supérieure, nous pouvons maintenant capturer plusieurs types d'exceptions avec un seul bloc catch.

Cela permet de réduire la répétition du code et d'améliorer la simplicité et l'efficacité du code.

Chaque type d'exception que peut traiter un bloc catch est séparé par un tiret vertical (|).

Its syntax is:

try {}}
　　//　code
} catch (ExceptionType1　| Exceptiontype2　ex) {　
　　//　catch block
}

To learn more information, please visitJava captures multiple exceptions.

try-with-resources statement

try-with-The resources statement is a try statement that has one or more resource declarations.

Its syntax is:

try (resource declaration) {
　　//　use of the resource
} catch (ExceptionType e1) {
　　//　catch block
}

Resources are objects that need to be closed at the end of the program. They must be declared and initialized within the try statement.

Let's take an example.

try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt"))) {
　　//　use of the resource
}

try-with-The resources statement is also known asAutomatic resource management. This statement automatically closes all resources at the end of the statement.

To learn more information, please visitJava try-with-resources statement.