Um mehrere Ausnahmen in Java zu behandeln, können wir:

• Mehrere Catch-Blöcke verwenden: Hier können Sie mehrere Ausnahmen unter mehreren Catch-Blöcken für einen entsprechenden Try-Block behandeln. Der Programmfluss kommt automatisch nacheinander zum Catch-Block und dann wird der entsprechende Catch-Block gemäß der Ausnahme gefunden und entsprechend behandelt.
• Verwenden Sie mehrere Catch-Anweisungen in Argumenten eines Catch-Blocks: Diese Funktion stammt aus Java 7. Hier können Sie mehrere Ausnahmen unter einem einzelnen Catch-Block (durch Pipe-Zeichen getrennt) für einen entsprechenden Try-Block behandeln. Der Programmfluss gelangt automatisch zum Catch-Block und dann wird die entsprechende Ausnahme in den Argumenten des Catch-Blocks für den Try-Block gefunden und entsprechend behandelt.

Mehrere Fangblöcke

In Java kann ein einzelner Try-Block mehrere Catch-Blöcke haben.

Warum brauchen wir in Java mehrere Catch-Blöcke?

In Java werden mehrere Catch-Blöcke verwendet, um verschiedene Arten von Ausnahmen zu behandeln. Wenn Anweisungen in einem einzelnen Try-Block mehrere Ausnahmen generieren, benötigen wir mehrere Catch-Blöcke, um verschiedene Arten von Ausnahmen zu behandeln. Dieser Mechanismus wird in Java als Multi-Catch-Block bezeichnet .

Auf einen Try-Block können ein oder mehrere Catch-Blöcke folgen. Jeder Catch-Block muss einen anderen Ausnahmehandler enthalten. Sie können verschiedene Ausnahmen in verschiedenen Catch- Blöcken abfangen, wenn diese einen anderen Ausnahmehandler enthalten. Wenn im Try-Block eine Ausnahme auftritt, wird der entsprechende Catch- Block ausgeführt, der diese bestimmte Ausnahme behandelt. Wenn Sie also beim Auftreten verschiedener Ausnahmen unterschiedliche Aufgaben ausführen müssen, können Sie den Multi-Try-Catch in Java verwenden.

Syntax

Die Syntax für die Verwendung eines einzelnen Try mit mehr als einem Catch-Block in Java lautet wie folgt:

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

Falls das ausgelöste Ausnahmeobjekt nicht mit dem ersten Catch-Block übereinstimmt, führt der zweite Catch-Block eine Überprüfung durch und so weiter.

Es tritt jeweils nur eine Ausnahme auf und es wird jeweils nur ein Catch-Block ausgeführt. Alle Catch-Blöcke müssen so angeordnet sein, dass die Ausnahme von der ersten Unterklasse und dann von der Oberklasse kommen muss, dh Catch für ArithmeticException muss vor Catch für Exception kommen.

Flussdiagramm des Multi-Catch-Blocks

Beispiele

Beispiel 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 , weil wir versuchen, eine Zahl durch 0 zu dividieren.
• ArrayIndexOutOfBoundException , weil wir ein neues Ganzzahl-Array mit den Array-Grenzen 0 bis 9 deklariert haben und versuchen, dem Index 10 einen Wert zuzuweisen.

Die Assoziativität des Zuweisungsoperators = ist von rechts nach links, daher wird zuerst eine ArithmeticException mit der Meldung / von Null ausgelöst.

Beispiel 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...

Abfangen mehrerer Ausnahmetypen mit einem Ausnahmehandler

In Java 7 und höher wurde der Catch- Block verbessert, um mehrere Ausnahmen in einem einzigen Catch- Block zu verarbeiten. Wenn Sie mehrere Ausnahmen abfangen und diese über ähnlichen Code verfügen.

Ein einzelner Catch- Block bietet die Möglichkeit, mehrere Ausnahmen zu behandeln (abzufangen), indem jede Ausnahme durch | getrennt wird (Pipe-Symbol) im Catch- Block.

Diese Funktion kann die Codeduplizierung reduzieren und die Effizienz erhöhen. Außerdem verringert sie die Versuchung, eine zu breite Ausnahme abzufangen. Der beim Kompilieren dieses Programms generierte Bytecode ist kleiner als der des Programms mit mehreren Catch- Blöcken , da keine Coderedundanz vorhanden ist.

Betrachten Sie das folgende Beispiel, das in jedem der Catch- Blöcke doppelten Code enthält :

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

In Java SE 7 und höher können wir mit diesem Ansatz den duplizierten Code entfernen

Syntax

Geben Sie in der catchKlausel die Ausnahmetypen an, die der Block verarbeiten kann, und trennen Sie jeden Ausnahmetyp durch einen vertikalen Strich ( |):

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

Beispiele

Beispiel 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

Der beim Kompilieren dieses Programms generierte Bytecode ist kleiner als der des Programms mit mehreren Catch- Blöcken, da es keine Code-Redundanz gibt.

Hinweis : Wenn ein Catch- Block mehr als einen Ausnahmetyp behandelt, ist der Catch- Parameter implizit final . In diesem Beispiel ist der Catch- Parameter ex final und Sie können ihm daher innerhalb des Catch- Blocks keine Werte zuweisen.

Dieser Ansatz wird normalerweise verwendet, wenn Sie mehrere Ausnahmen abfangen und diese über ähnlichen Code verfügen. aber wir können es auch nach Belieben nutzen.

Beispiel 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");
    }
  }
}

Beim Abfangen mehrerer Ausnahmen in einem einzelnen Catch- Block wird die Regel verallgemeinert und dann spezialisiert.

Das bedeutet, dass wir bei einer Hierarchie von Ausnahmen im Catch- Block nur die Basisausnahme abfangen können, anstatt mehrere spezialisierte Ausnahmen abzufangen.

Nehmen wir ein Beispiel.

Beispiel 1: Nur Basisausnahmeklasse abfangen

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

Wenn die Basisausnahmeklasse bereits im Catch- Block angegeben wurde, verwenden Sie keine untergeordneten Ausnahmeklassen im selben Catch- Block. Andernfalls erhalten wir einen Kompilierungsfehler.

Nehmen wir ein Beispiel.

Beispiel 2: Basis- und untergeordnete Ausnahmeklassen abfangen

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

Programm

In einigen Fällen kann ein einzelner Codeabschnitt mehr als eine Ausnahme auslösen. Um diese Art von Situation zu bewältigen, können Sie zwei oder mehr Catch-Klauseln angeben, die jeweils einen anderen Ausnahmetyp abfangen. Wenn eine Ausnahme ausgelöst wird, wird jede Catch-Anweisung der Reihe nach überprüft und die erste ausgeführt, deren Typ mit dem der Ausnahme übereinstimmt. Nachdem eine Catch-Anweisung ausgeführt wurde, werden die anderen umgangen und die Ausführung wird nach dem Try/Catch-Block fortgesetzt. Das folgende Beispiel fängt zwei verschiedene Ausnahmetypen ab:

// Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[]) {
try {
    int a = args.length;
    System.out.println("a = " + a);
    int b = 42 / a;
    int c[] = { 1 };
    c[42] = 99;
} catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
    System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}

Hier ist die Ausgabe, die durch die Ausführung in beide Richtungen generiert wird:

C:\>java MultiCatch
a = 0
Divide by 0: java.lang.ArithmeticException: / by zero
After try/catch blocks.
C:\>java MultiCatch TestArg
a = 1
Array index oob: java.lang.ArrayIndexOutOfBoundsException:42
After try/catch blocks.

/* This program contains an error.
A subclass must come before its superclass in
a series of catch statements. If not,
unreachable code will be created and a
compile-time error will result.
*/
class SuperSubCatch {
public static void main(String args[]) {
    try {
        int a = 0;
        int b = 42 / a;
    } catch(Exception e) {
        System.out.println("Generic Exception catch.");
    }
    /* This catch is never reached because
    ArithmeticException is a subclass of Exception. */
    catch(ArithmeticException e) { // ERROR - unreachable
        System.out.println("This is never reached.");
    }
}
}

Treten Sie der Mouad Oumous Java WhatsApp-Gruppe bei

Treten Sie dem Telegram-Kanal von Mouad Oumous bei

Semaphor | Java Concurrent API Java Concurrent API-Pakete – Teil 1 Java – 8 | BiFunction-, BiConsumer- und BiPredicate-Schnittstelle mit Beispiel