Capturer plusieurs exceptions en Java

Feb 17 2023

Pour gérer plusieurs exceptions en java, nous pouvons : Plusieurs blocs catch En Java, un seul bloc try peut avoir plusieurs blocs catch. Pourquoi avons-nous besoin de plusieurs blocs catch en Java ? Plusieurs blocs catch en Java sont utilisés pour gérer différents types d'exceptions.

Pour gérer plusieurs exceptions en java nous pouvons :

Utiliser plusieurs blocs catch : ici, vous pouvez gérer plusieurs exceptions sous plusieurs blocs catch pour un bloc try correspondant. Le flux de programme viendra automatiquement au bloc catch un par un, puis le bloc catch correspondant sera trouvé selon 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ées par un signe pipe) pour un bloc try correspondant. Le déroulement du programme viendra automatiquement au bloc catch, puis l'exception correspondante à l'intérieur des arguments du bloc catch sera trouvée pour le bloc try et sera traitée en conséquence.

Blocs de capture multiples

En Java, un seul bloc try peut avoir plusieurs blocs catch.

Pourquoi avons-nous besoin de plusieurs blocs catch en Java ?

Plusieurs blocs catch en Java sont utilisés pour gérer différents types d'exceptions. Lorsque les instructions d'un seul bloc try génèrent plusieurs exceptions, nous avons besoin de plusieurs blocs catch pour gérer différents types d'exceptions. Ce mécanisme est appelé bloc multi-catch en java .

Un bloc try peut être suivi d'un ou plusieurs blocs catch. Chaque bloc catch doit contenir un gestionnaire d'exception différent. Vous pouvez intercepter différentes exceptions dans différents blocs catch s'il contient un gestionnaire d'exceptions différent. Lorsqu'une exception se produit dans le bloc try, le bloc catch correspondant qui gère cette exception particulière s'exécute. Ainsi, si vous devez effectuer différentes tâches lors de l'apparition de différentes exceptions, vous pouvez utiliser le catch multi-try en Java.

Syntaxe

La syntaxe pour utiliser un seul essai avec plus d'un bloc catch en Java est la suivante :

try 
{ 
  statements; 
} 
catch(ExceptionType1 e1) 
{ 
  statements; 
} 
catch(ExceptionType2 e2) 
{ 
  statements; 
}

Dans le cas où l'objet d'exception lancé ne correspond pas au premier bloc catch, le deuxième bloc catch vérifiera, et ainsi de suite.

À la fois, une seule exception se produit et à la fois, un seul bloc catch est exécuté. Tous les blocs catch doivent être disposés de telle manière que l'exception doit provenir de la première sous-classe puis de la superclasse, c'est-à-dire que catch pour ArithmeticException doit venir avant catch pour Exception.

Organigramme du bloc multi-catch

Exemples

Exemple 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException e) {
      System.out.println(e.getMessage());
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    } 
  }
}

/ by zero

ArithmeticException car nous essayons de diviser un nombre par 0.
ArrayIndexOutOfBoundException car nous avons déclaré un nouveau tableau d'entiers avec des limites de tableau de 0 à 9 et nous essayons d'attribuer une valeur à l'index 10.

L'associativité de l'opérateur d'affectation = est de droite à gauche, donc une ArithmeticException est lancée en premier avec le message / par zéro.

Exemple 2

class Example2{
   public static void main(String args[]){
     try{
         int a[]=new int[7];
         a[4]=30/0;
         System.out.println("First print statement in try block");
     }
     catch(ArithmeticException e){
        System.out.println("Warning: ArithmeticException");
     }
     catch(ArrayIndexOutOfBoundsException e){
        System.out.println("Warning: ArrayIndexOutOfBoundsException");
     }
     catch(Exception e){
        System.out.println("Warning: Some Other exception");
     }
   System.out.println("Out of try-catch block...");
  }
}

Warning: ArithmeticException
Out of try-catch block...

Capture de plusieurs types d'exceptions avec un seul gestionnaire d'exceptions

Dans Java 7 et versions ultérieures, le bloc catch a été amélioré pour gérer plusieurs exceptions dans un seul bloc catch . Si vous attrapez plusieurs exceptions et qu'elles ont un code similaire.

Un seul bloc catch a la possibilité de gérer (attraper) plusieurs exceptions en les séparant par | (symbole de tuyau) dans le bloc catch .

Cette fonctionnalité peut réduire la duplication de code et augmenter l'efficacité, ainsi que réduire la tentation d'attraper une exception trop large. Le bytecode généré lors de la compilation de ce programme sera plus petit que le programme ayant plusieurs blocs catch car il n'y a pas de redondance de code.

Prenons l'exemple suivant, qui contient du code en double dans chacun des blocs catch :

catch (IOException ex) {
     logger.log(ex);
     ex.printStackTrace();
catch (SQLException ex) {
     logger.log(ex);
     ex.printStackTrace();
}

Dans Java SE 7 et versions ultérieures, nous pouvons éliminer le code dupliqué en utilisant cette approche

Syntaxe

Dans la catchclause, spécifiez les types d'exceptions que block peut gérer et séparez chaque type d'exception par une barre verticale ( |) :

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

Exemples

Exemple 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

Le bytecode généré lors de la compilation de ce programme sera plus petit que le programme ayant plusieurs blocs catch car il n'y a pas de redondance de code.

Remarque : Si un bloc catch gère plusieurs types d'exception, le paramètre catch est implicitement final . Dans cet exemple, le paramètre catch ex est final et vous ne pouvez donc lui attribuer aucune valeur dans le bloc catch .

Cette approche est généralement utilisée si vous interceptez plusieurs exceptions et qu'elles ont un code similaire. mais nous pouvons aussi l'utiliser comme bon nous semble.

Exemple 2

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException|ArrayIndexOutOfBoundsException e) {
      if (e instanceof ArithmeticException)
          System.out.println("ArithmeticException");
      else
          System.out.println("ArrayIndexOutOfBoundsException");
    }
  }
}

Lors de la capture de plusieurs exceptions dans un seul bloc catch , la règle est généralisée à spécialisée.

Cela signifie que s'il existe une hiérarchie d'exceptions dans le bloc catch , nous ne pouvons intercepter que l'exception de base au lieu d'intercepter plusieurs exceptions spécialisées.

Prenons un exemple.

Exemple 1 : Capture de la classe d'exception de base uniquement

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

Si la classe d'exception de base a déjà été spécifiée dans le bloc catch , n'utilisez pas de classes d'exception enfants dans le même bloc catch . Sinon, nous aurons une erreur de compilation.

Prenons un exemple.

Exemple 2 : Intercepter les classes de base et les classes d'exception enfants

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

Main.java:6: error: Alternatives in a multi-catch statement cannot be related by subclassing

Programme

Dans certains cas, plusieurs exceptions peuvent être déclenchées par un seul morceau de code. Pour gérer ce type de situation, vous pouvez spécifier deux ou plusieurs clauses catch, chacune interceptant un type d'exception différent. Lorsqu'une exception est levée, chaque instruction catch est inspectée dans l'ordre, et la première dont le type correspond à celui de l'exception est exécutée. Après l'exécution d'une instruction catch, les autres sont ignorées et l'exécution continue après le bloc try/catch. L'exemple suivant intercepte deux types d'exception différents :