Die Verwendung von Try- und Catch-Codeblöcken zur Ausnahmebehandlung in Java

Verwendung von Java Try and Catch
Obwohl die vom Java-Laufzeitsystem bereitgestellten Standard-Ausnahmehandler für das Debuggen nützlich sind, möchten Sie normalerweise Ausnahmen selbst behandeln. Dies hat zwei Vorteile. Erstens ermöglicht es Ihnen, Fehler zu korrigieren. Zweitens verhindert es, dass das Programm automatisch beendet wird. Die meisten Benutzer sind gelinde gesagt verärgert darüber, dass beim Beenden des Programms und beim Auftreten eines Fehlers ein Stack-Trace gedruckt wird. Glücklicherweise ist dies leicht vermeidbar.

Um einen Laufzeitfehler zu verhindern und zu behandeln, fügen Sie einfach den Code, den Sie überwachen möchten, in einen Try-Block ein. Fügen Sie unmittelbar nach dem Try-Block eine Catch-Klausel ein, die den Typ des Fehlers angibt, den Sie abfangen möchten. Die Bewältigung dieser Aufgabe ist einfach. Das folgende Programm enthält einen Try-Block und eine Catch-Klausel, die durch Division durch Null verursachte ArithmeticException-Ausnahmen behandelt.

class Exc2 {
  public static void main(String args[]) {
    int d, a;
    try { // monitor a block of code.
      d = 0;
      a = 42 / d;
      System.out.println("This will not be printed.");
    } catch (ArithmeticException e) { // catch divide-by-zero error
      System.out.println("Division by zero.");
    }
    System.out.println("After catch statement.");
  }
}

Die Programmausgabe lautet wie folgt:

Division by zero.
After catch statement.

Beachten Sie, dass der Aufruf von println() im try-Block nie ausgeführt wird. Sobald eine Ausnahme ausgelöst wird, wird die Programmsteuerung vom Try-Block an den Catch-Block übertragen. Die Ausführung „kehrt“ nie vom Catch-Block zum Try-Block zurück. Daher wird „Dies wird nicht gedruckt“

nicht angezeigt. Sobald die Catch-Anweisung ausgeführt wird, wird die Programmsteuerung ab der Zeile unterhalb des gesamten Try/Catch-Mechanismus fortgesetzt.

Ein Versuch und seine Catch-Anweisung bilden eine Einheit. Der Geltungsbereich der Catch-Klausel ist auf die Anweisungen beschränkt, die vor der Try-Anweisung definiert sind. Eine Catch-Anweisung kann keine Ausnahme abfangen, die von einer anderen Try-Anweisung ausgelöst wurde (außer im Fall verschachtelter Try-Anweisungen).

Durch try geschützte Anweisungsdeklarationen müssen in einer geschweiften Klammer stehen (d. h. sie müssen sich in einem Block befinden). Sie können try nicht alleine verwenden.

Der Zweck der Erstellung einer Catch-Klausel besteht darin, Ausnahmen aufzulösen und die Ausführung fortzusetzen, als ob der Fehler nicht aufgetreten wäre. Im folgenden Programm beispielsweise liefert jede Iteration der for-Schleife zwei zufällige Ganzzahlen. Diese beiden ganzen Zahlen werden durcheinander dividiert und das Ergebnis wird zur Division von 12345 verwendet. Das Endergebnis wird in a gespeichert. Wenn eine Divisionsoperation zu einem Division-durch-Null-Fehler führt, wird dieser abgefangen, der Wert von a wird auf Null gesetzt und das Programm wird fortgesetzt.

// Handle an exception and move on.
import java.util.Random;
 
class HandleError {
  public static void main(String args[]) {
    int a=0, b=0, c=0;
    Random r = new Random();
 
    for(int i=0; i<32000; i++) {
      try {
        b = r.nextInt();
        c = r.nextInt();
        a = 12345 / (b/c);
      } catch (ArithmeticException e) {
        System.out.println("Division by zero.");
        a = 0; // set a to zero and continue
      }
      System.out.println("a: " + a);
    }
  }
}

Eine Beschreibung der Ausnahme anzeigen

Throwable überlädt die toString()-Methode (definiert durch Object), sodass eine Zeichenfolge mit der Ausnahmebeschreibung zurückgegeben wird. Sie können eine Beschreibung einer Ausnahme anzeigen, indem Sie ihr in println() einen Parameter übergeben. Beispielsweise könnte der Catch-Block des vorherigen Programms als

catch (ArithmeticException e) {
  System.out.println("Exception: " + e);
  a = 0; // set a to zero and continue
}

umgeschrieben werden. Wenn diese Version durch die Version im Originalprogramm ersetzt wird und das Programm unter dem Standard-JavaJDK-Interpreter ausgeführt wird, wird jede Teilung ausgeführt -by-zero-Fehler zeigt die folgende Meldung an:

Exception: java.lang.ArithmeticException: / by zero

Obwohl es im Kontext keinen besonderen Wert hat, kann die Möglichkeit, eine Ausnahmebeschreibung anzuzeigen, in anderen Situationen nützlich sein – insbesondere beim Experimentieren und Debuggen Ausnahmen.

Verwendung mehrerer Java-Catch-Anweisungen
In einigen Fällen können mehrere Ausnahmen durch ein einzelnes Codesegment verursacht werden. Um mit dieser Situation umzugehen, können Sie zwei oder mehr Catch-Klauseln definieren, die jeweils einen Ausnahmetyp abfangen. Wenn eine Ausnahme ausgelöst wird, wird jede Catch-Klausel der Reihe nach überprüft und die erste, die dem Ausnahmetyp entspricht, wird ausgeführt. Wenn eine Catch-Anweisung ausgeführt wird, werden andere Klauseln umgangen und die Ausführung wird ab dem Code nach dem Try/Catch-Block fortgesetzt. Das folgende Beispiel entwirft zwei verschiedene Ausnahmetypen:

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

Das Programm, das in der Startbedingung ohne Befehlszeilenparameter ausgeführt wird, führt zu einer Division durch Null-Ausnahme, da a 0 ist. Wenn Sie ein Befehlszeilenargument angeben, bleibt es erhalten und setzt a auf einen Wert größer als Null. Dies führt jedoch zu einer ArrayIndexOutOf BoundsException-Ausnahme, da die Länge des ganzzahligen Arrays c 1 beträgt und das Programm versucht, c[42] einen Wert zuzuweisen.

Hier ist die Ausgabe der Ausführung des Programms in zwei verschiedenen Situationen:

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 After try/catch blocks.

Wenn Sie mehrere Catch-Anweisungen verwenden, denken Sie daran, dass Ausnahmeunterklassen vor allen ihren übergeordneten Klassen verwendet werden müssen wichtig. Dies liegt daran, dass die Verwendung der Catch-Anweisung der übergeordneten Klasse Ausnahmen dieses Typs und aller seiner Unterklassen abfängt. Auf diese Weise wird die untergeordnete Klasse niemals eintreffen, wenn die untergeordnete Klasse hinter der übergeordneten Klasse liegt. Darüber hinaus ist nicht erreichbarer Code in Java ein Fehler. Betrachten Sie beispielsweise das folgende Programm:

/* 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 acompile-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.");
    }
  }
}

Wenn Sie versuchen, dieses Programm zu kompilieren, erhalten Sie eine Fehlermeldung, die besagt, dass die zweite Catch-Anweisung nicht erreicht wird, da die Ausnahme bereits erfasst wurde. Da ArithmeticException eine Unterklasse von Exception ist, behandelt die erste Catch-Anweisung alle Exception-orientierten Fehler, einschließlich ArithmeticException. Das bedeutet, dass die zweite Catch-Anweisung niemals ausgeführt wird. Um das Programm zu ändern, kehren Sie die Reihenfolge der beiden Catch-Anweisungen um.

Weitere Artikel zur Verwendung von Try-and-Catch-Codeblöcken für die Ausnahmebehandlung in Java finden Sie auf der chinesischen PHP-Website!