In Java kann eine try-Anweisung innerhalb des Blocks eines anderen try stehen. Es wird als verschachtelter Try-Block bezeichnet. Jedes Mal, wenn eine try-Anweisung eingegeben wird, wird der Kontext dieser Ausnahme auf den Stapel verschoben.

Warum einen verschachtelten Try-Block verwenden?

Manchmal kann es vorkommen, dass ein Teil eines Blocks einen Fehler verursacht und der gesamte Block selbst einen anderen Fehler verursacht. In solchen Fällen müssen Ausnahmebehandler geschachtelt werden.

Syntax

try {
   statement 1;
   statement 2;
   try {
      statement 1;
      statement 2;
   }
   catch(Exception e) {
      // catch the corresponding exception  
   }  
}
catch(Exception e) {
   // catch the corresponding exception
}
   .............

// An example of nested try statements.
class NestTry {
public static void main(String args[]) {
    try {
        int a = args.length;
        /* If no command-line args are present,
        the following statement will generate
        a divide-by-zero exception. */
        int b = 42 / a;
        System.out.println("a = " + a);
        try { // nested try block
            /* If one command-line arg is used,
            then a divide-by-zero exception
            will be generated by the following code. */
            if(a==1) a = a/(a-a); // division by zero
            /* If two command-line args are used,
            then generate an out-of-bounds exception. */
            if(a==2) {
                int c[] = { 1 };
                c[42] = 99; // generate an out-of-bounds exception
            }
        } catch(ArrayIndexOutOfBoundsException e) {
        System.out.println("Array index out-of-bounds: " + e);
        }
    } catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
    }
  }
}

Keine Befehlszeile: Wenn Sie das Programm ohne Befehlszeilenargumente ausführen, wird vom äußeren Try-Block eine Division-durch-Null-Ausnahme generiert.

Ein Befehlszeilenargument: Die Ausführung des Programms mit einem Befehlszeilenargument generiert eine Division-durch-Null-Ausnahme innerhalb des verschachtelten Try-Blocks. Da der innere Block diese Ausnahme nicht abfängt, wird sie an den äußeren Try-Block weitergeleitet, wo sie behandelt wird.

Zwei Befehlszeilenargumente : Wenn Sie das Programm mit zwei Befehlszeilenargumenten ausführen, wird eine Array-Grenzenausnahme innerhalb des inneren Try-Blocks generiert. Hier sind Beispielläufe, die jeden Fall veranschaulichen:

C:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One
a = 1
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One Two
a = 2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException:42

Dies ist manchmal unvermeidlich, insbesondere wenn Ihr Wiederherstellungscode möglicherweise eine Ausnahme auslöst. Nicht schön, aber manchmal gibt es keine Alternativen.

Randnotizen

• Wenn eine innere Try-Anweisung keine passende Catch-Anweisung für eine bestimmte Ausnahme hat, wird die Steuerung an die nächsten Try-Anweisungs- Catch-Handler übertragen , die für eine passende Catch-Anweisung erwartet werden.
• Dies wird so lange fortgesetzt, bis eine der Catch-Anweisungen erfolgreich ist oder bis alle verschachtelten Try- Anweisungen ausgeführt wurden.
• Wenn keine Catch-Anweisungen übereinstimmen, behandelt das Java-Laufzeitsystem die Ausnahme. Jedes Mal, wenn ein Try-Block keinen Catch-Handler für eine bestimmte Ausnahme hat , werden die Catch-Blöcke des übergeordneten Try-Blocks auf diese Ausnahme überprüft, wenn eine Übereinstimmung mit der Ausführung dieses Catch-Blocks gefunden wird. Wenn weder der Catch-Block noch der übergeordnete Catch-Block eine Ausnahme behandelt Dann wird die vom Laufzeitsystem generierte Meldung für die Ausnahme angezeigt, ähnlich wie wir sie sehen, wenn wir keine Ausnahme behandeln.
• Bei Verwendung verschachtelter Try-Blöcke wird der innere Try-Block zuerst ausgeführt. Jede im inneren Try-Block ausgelöste Ausnahme wird im entsprechenden Catch-Block abgefangen. Wenn kein passender Catch-Block gefunden wird, wird der Catch-Block des äußeren Try-Blocks überprüft, bis alle verschachtelten Try-Anweisungen erschöpft sind. Wenn keine passenden Blöcke gefunden werden, übernimmt die Java Runtime Environment die Ausführung.

// An example of nested try statements.
class NestTry {
public static void main(String args[]) {
try {
  int a = args.length;
  /* If no command-line args are present,
  the following statement will generate
  a divide-by-zero exception. */
  int b = 42 / a;
  System.out.println("a = " + a);
  try { // nested try block
    /* If one command-line arg is used,
    then a divide-by-zero exception
    will be generated by the following code. */
    if(a==1) a = a/(a-a); // division by zero
    /* If two command-line args are used,
    then generate an out-of-bounds exception. */
    if(a==2) {
      int c[] = { 1 };
      c[42] = 99; // generate an out-of-bounds exception
  }
  } catch(ArrayIndexOutOfBoundsException e) {
  System.out.println("Array index out-of-bounds: " + e);
}
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}

C:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One
a = 1
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One Two
a = 2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException:42

/* Try statements can be implicitly nested via
calls to methods. */
class MethNestTry {
static void nesttry(int a) {
  try { // nested try block
    /* If one command-line arg is used,
    then a divide-by-zero exception
    will be generated by the following code. */
    if(a==1) a = a/(a-a); // division by zero
    /* If two command-line args are used,
    then generate an out-of-bounds exception. */
    if(a==2) {
      int c[] = { 1 };
      c[42] = 99; // generate an out-of-bounds exception
  }
  } catch(ArrayIndexOutOfBoundsException e) {
      System.out.println("Array index out-of-bounds: " + e);
  }
}
public static void main(String args[]) {
  try {
    int a = args.length;
    /* If no command-line args are present,
    the following statement will generate
    a divide-by-zero exception. */
    int b = 42 / a;
    System.out.println("a = " + a);
    nesttry(a);
  } catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
  }
}
}

Danke fürs Lesen. Viel Spaß beim Lernen

Treten Sie der Mouad Oumous Java WhatsApp-Gruppe bei

Treten Sie dem Telegram-Kanal von Mouad Oumous bei

Unterstützen Sie unsere Publikation, indem Sie ihr folgen