Bloc de capture multiple en Java

Nous pouvons gérer les exceptions dans notre code en insérant des blocs try-catch en Java. Ici, dans cet article, nous verrons comment gérer plusieurs exceptions pour un seul bloc try en utilisant plusieurs blocs catch ou plusieurs arguments pour un bloc catch.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

La syntaxe des blocs Catch multiples en Java est indiquée ci-dessous :

Syntaxe 1 : bloc try-catch simple

try
{
//code snippet which might responsible for exceptions
}
catch (<type_of_exception> <name_of_exception_object>)‏
{
//here we handle exceptions
}

Syntaxe 2 : bloc try-catch avec plusieurs blocs catch

try
{
//code snippet which might responsible for exceptions
}
catch (<type_of_exception> <name_of_exception_object>)‏ //catch block 1
{
//here we handle exceptions
}
catch (<type_of_exception> <name_of_exception_object>)‏ //catch block 2
{
//here we handle exceptions
}
catch (<type_of_exception> <name_of_exception_object>)‏ //catch block 3
{
//here we handle exceptions
}

Syntaxe 3 : bloc try-catch avec plusieurs instructions catch comme argument du bloc catch

try
{
//code snippet which might responsible for exceptions
}
catch (<type_of_exception1> | <type_of_exception2> | <type_of_exception3> <name_of_exception_object>)‏
{
//here we handle exceptions
}

Comment fonctionne le bloc Catch en Java ?

Dans un premier temps, nous devons vérifier le bloc try avant de passer au bloc catch.

1. Essayez de bloquer

Il contient l'extrait de code qui peut entraîner des exceptions. Ainsi, chaque fois que vous pensez que votre code pourrait entraîner une exception, placez cet extrait de code dans un bloc try. Au moins un bloc catch est nécessaire pour un bloc try.

2. Attraper le bloc

Il contient l'extrait de code qui gère l'exception qui peut survenir pour le code écrit dans son bloc try correspondant. Maintenant, comment gérer plusieurs exceptions, le cas échéant ?

Vous pouvez emprunter deux manières :

• Utiliser plusieurs catch pour un bloc try : Ici, vous pouvez gérer plusieurs exceptions sous plusieurs blocs catch pour un bloc try correspondant. Le flux du programme arrivera automatiquement au bloc catch un par un, puis le bloc catch correspondant sera trouvé conformément à l'exception et sera traité en conséquence.
• Utiliser plusieurs instructions Catch dans les arguments d'un bloc Catch : Cette fonctionnalité provient de Java 7. Ici, vous pouvez gérer plusieurs exceptions sous un seul bloc catch (séparés par un signe pipe) pour un bloc try correspondant. Le flux du programme arrivera automatiquement au bloc catch, puis l'exception correspondante dans les arguments du bloc catch sera trouvée pour le bloc try et sera traitée en conséquence.

Constructeur

Nous pouvons également écrire des blocs try-catch dans un constructeur et cela fonctionnera comme prévu. Dans l'exemple ci-dessous, nous écrirons du code dans le constructeur try : le bloc try générera une exception arithmétique qui est gérée dans un bloc catch.

public class MultipleCatchBlockInConstructor
{
MultipleCatchBlockInConstructor()
{
try
{
int num=6/0;
}
catch(ArrayIndexOutOfBoundsException excp)
{
System.out.println("Exception is : "+excp);
}
catch(ArithmeticException excp)
{
System.out.println("Exception is : "+ excp);
}
}
public static void main(String[] args) {
MultipleCatchBlockInConstructor mc=new MultipleCatchBlockInConstructor();
}
}

Sortie :

Exemples de blocs Catch multiples en Java

Dans cette section, nous discuterons de nombreux exemples de code. Vous devriez essayer ce code par vous-même et comparer les sorties avec celle donnée.

Exemple n°1

Il s'agit d'un exemple simple de bloc multi-catch, dans lequel nous avons écrit une instruction qui générera des exceptions à l'intérieur du bloc try, qui seront gérées par un bloc catch correspondant parmi trois blocs catch.

Code :

public class MultipleCatchBlockInJava {
public static void main(String[] args) {
try{
System.out.println("start of try block");
int num = 6/0;
}
catch(ArithmeticException e)
{
System.out.println("divide by zero exception ");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("ArrayIndexOutOfBounds Exception occurs");
}
catch(Exception e)
{
System.out.println("Any other excpetion");
}
System.out.println("end of try-catch block");
}
}

Sortie :

Exemple n°2

Dans cet exemple, nous avons illustré la gestion des exceptions hors limites pour un tableau par bloc try and catch.

Code :

public class MultipleCatchBlockInJava {
public static void main(String[] args) {
try{
System.out.println("start of try block");
int arr[]=new int[6];
System.out.println(arr[12]); //we want to access 12th element of array which does not exist as size is of 6
}
catch(ArithmeticException e)
{
System.out.println("divide by zero exception");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array IndexOutOfBounds Exception occurs");
}
catch(Exception e)
{
System.out.println("Any other exception");
}
System.out.println("end of try-catch block");
}
}

Sortie :

Exemple #3

Dans cet exemple, nous verrons comment le pointeur nul est géré par un bloc catch. Notez également qu'il existe plusieurs scénarios d'exceptions dans le bloc try, mais une fois que le flux du programme atteint la première instruction génératrice d'exception (ici, l'exception Nullpointer), il sortira immédiatement du bloc try et recherchera le gestionnaire d'exceptions dans un bloc catch. L'autre instruction génératrice d'exception (ici, Array index out of Bound exception) à l'intérieur du bloc try est ignorée.

Code :

public class MultipleCatchBlockInJava {
public static void main(String[] args) {
try{
System.out.println("start of try block");
String str=null;
System.out.println(str.length());  //we want to get length of a null string
int arr[]=new int[6];
System.out.println(arr[12]); //we want to access 12th element of array which does not exist as size is of 6
}
catch(ArithmeticException e)
{
System.out.println("divide by zero exception");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array IndexOutOfBounds Exception occurs");
}
catch(NullPointerException e)
{
System.out.println("Null pointer Exception occurs");
}
System.out.println("end of try-catch block");
}
}

Sortie :

Exemple n°4

Dans cet exemple, nous vérifierons comment les exceptions seront gérées par plusieurs arguments d'un seul bloc catch.

Code :

public class MultipleCatchBlockInJava {
public static void main(String[] args) {
try{
System.out.println("start of try block");
String str=null;
System.out.println(str.length());  //we want to get length of a null string
int arr[]=new int[6];
System.out.println(arr[10]); //we want to access 10th element of array which does not exist as size is of 6
}
catch(ArithmeticException | ArrayIndexOutOfBoundsException | NullPointerException e )
{
System.out.println("Code is throwing " + e);
}
System.out.println("end of try-catch block");
}
}

Sortie :

Conclusion

Ceci conclut notre apprentissage de plusieurs blocs catch du point de vue de la programmation Java. Pour résumer : chaque fois que vous devez gérer plusieurs exceptions, vous pouvez les écrire dans plusieurs blocs catch. Alternativement, pour Java 7 et versions ultérieures, vous pouvez écrire plusieurs exceptions dans les arguments d'un seul bloc catch et le flux du programme les sélectionnera automatiquement. De plus, il est important que vous écriviez vous-même les codes pour une meilleure compréhension.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!