Java-Exception-Verarbeitung

In diesem Tutorial werden Sie anhand von Beispielen lernen, wie Sie Ausnahmen mit Java behandeln. Um Ausnahmen zu behandeln, verwenden wir den try ... catch ... finally-Block.

Im vorherigen Tutorial haben wir die Ausnahmen kennengelernt. Ausnahmen sind unerwartete Ereignisse während der Ausführung des Programms.

Erfassen und behandeln von Ausnahmen

In Java verwenden wir die Komponenten der Exception-Verarbeitung try, catch und finally-Block, um Ausnahmen zu behandeln.

Um Ausnahmen zu erfassen und zu behandeln, platzieren wir den try...catch...finally-Codeblock um den Code, der möglicherweise Ausnahmen erzeugt. Der finally-Block ist optional.

Die Syntax von try...catch...finally lautet:

try {}}
　　//　Code
} catch (ExceptionType e) {　
　　//　catch-Block
} finally {
　　//finally-Block
}

Java try ... catch-Block

Code, der möglicherweise Ausnahmen erzeugt, wird im try-Block platziert.

Jeder try-Block sollte sofort gefolgt von einem catch- oder finally-Block sein. Wenn eine Ausnahme auftritt, wird sie vom Block nach dem catch erfasst.

　catch-Blöcke können nicht单独使用，必须紧跟在try-Block.

Beispiel1：try ... catch-Block

class Main {
　　public static void main(String[] args) {
　　　　try {}}
　　　　　　int divideByZero =　5　/　0;
　　　　　　System.out.println("Der Rest des Codes im try-Block");
　　　　} catch (ArithmeticException e) {
　　　　　　System.out.println("ArithmeticException => ");　+　e.getMessage());
　　　　}
　　}
}

Ausgaberesultat

ArithmeticException =>　/　durch Null

In diesem Beispiel

• Wir teilen die Zahl durch 0 im try-Block. Dies führt zu einer ArithmeticException.

• Wenn eine Ausnahme auftritt, überspringt das Programm den Rest des Codes im try-Block.

• Hier erstellen wir einen catch-Block, um ArithmeticException zu behandeln. Daher werden die Anweisungen im catch-Block ausgeführt.

Wenn alle Anweisungen im try-Block keine Ausnahme erzeugen, wird der catch-Codeblock übersprungen.

多个捕获块

Für jeden try-Block kann es null oder mehrere catch-Blöcke geben.

Der Parameter-Typ jeder catch-Block-Parameter gibt an, welche Ausnahmen behandelt werden können. Mehrere catch-Blöcke ermöglichen es uns, jede Ausnahme auf eine andere Weise zu behandeln.

Beispiel2：多个捕获块

class ListOfNumbers {
　　public int[] arrayOfNumbers = new int[10];
　　public void writeList() {
　　　　try {}}
　　　　　　arrayOfNumbers[10] =　11;
　　　　} catch (NumberFormatException e1) {
　　　　　　System.out.println("NumberFormatException => "　+　e1.getMessage());
　　　　} catch (IndexOutOfBoundsException e2) {
　　　　　　System.out.println("IndexOutOfBoundsException => ");　+　e2.getMessage());
　　　　}
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　ListOfNumbers list = new ListOfNumbers();
　　　　list.writeList();
　　}
}

Ausgaberesultat

IndexOutOfBoundsException => Index　10　out of bounds for length　10

In diesem Beispiel erklären wir eine Größe von10 zuweisen, der die Ganzzahl-Array arrayOfNumbers enthält.

Wir wissen, dass Array-Indizes immer von 0 beginnen. Daher wird, wenn wir versuchen, den Wert für den Index10wird IndexOutOfBoundsException aufgetreten, da die Grenzen des Arrays arrayOfNumbers von 0 bis9.

Wenn im try-Block eine Ausnahme auftritt

• Die Ausnahme wird an den ersten catch-Block weitergegeben. Der erste catch-Block behandelt die Exception IndexOutOfBoundsException nicht, daher wird sie an den nächsten catch-Block weitergegeben.

• Der zweite catch-Block im obigen Beispiel ist der angemessene Ausnahmebehandler, da er IndexOutOfBoundsException behandelt. Daher wird er ausgeführt.

Java Finally-Block

Für jeden try-Block kann nur ein finally-Block vorhanden sein.

Der finally-Block ist optional. Wenn jedoch definiert, wird er immer ausgeführt (selbst wenn keine Ausnahme auftritt).

Wird eine Ausnahme aufgetreten, wird der finally-Block nach dem try...catch-Block ausgeführt. Wird keine Ausnahme aufgetreten, wird der try-Block ausgeführt.

Die grundlegende Syntax des finally-Blocks ist:

try {}}
　　//code
} catch (ExceptionType1　e1) {　
　　//　catch-Block
} catch (ExceptionType1　e2) {
　//　catch-Block
} finally {
　　//Der finally-Block wird immer ausgeführt
}

Beispiel3Beispiel: finally-Block

class Main {
　　public static void main(String[] args) {
　　　　try {}}
　　　　　　int divideByZero =　5　/　0;
　　　　} catch (ArithmeticException e) {
　　　　　　System.out.println("ArithmeticException => ");　+　e.getMessage());
　　　　} finally {
　　　　　　System.out.println("Der finally-Block wird immer ausgeführt");
　　　　}
　　}
}

Ausgaberesultat

ArithmeticException =>　/　durch Null
Der finally-Block wird immer ausgeführt

In diesem Beispiel teilen wir eine Zahl durch Null. Dies führt zu einer ArithmeticException, die vom catch-Block erfasst wird, und der finally-Block wird immer ausgeführt.

Die Verwendung eines finally-Blocks wird als gute Praxis angesehen. Dies liegt daran, dass er wichtige Bereinigungscode enthält, wie z.B.

• Kodestücke, die möglicherweise durch return-, continue- oder break-Anweisungen unerwartet übersprungen werden

• Dateien oder Verbindungen schließen

Wir haben bereits erwähnt, dass der finally-Block immer ausgeführt wird, normalerweise so.

• Die Verwendung der Methode System.exit()

• Eine Ausnahme im finally-Block

• Der Thread wird beendet

Beispiel4Beispiel: try, catch und finally

Lassen Sie uns ein Beispiel nennen, wir versuchen, eine neue Datei mit FileWriter zu erstellen und Daten mit PrintWriter zu schreiben.

import java.io.*;
class ListOfNumbers {
　　private int[] list = new int[10];
　　public ListOfNumbers() {
　　　　//Ganzzahlwerte im Listenarray speichern
　　　　for (int i = 0; i <　10; i++) {
　　　　　　list[i] = i;
　　　　}　	
　　}
}
　　public void writeList() {
　　　　PrintWriter out = null;
　　　　try {}}
　　　　　　System.out.println("Eingang in den try-Statement");
　　　　　　//Eine neue Datei OutputFile.txt erstellen
　　　　　　out = new PrintWriter(new FileWriter("OutputFile.txt"));
　　　　　　//Werte aus dem Listenarray in die neu erstellte Datei schreiben
　　　　　　for (int i = 0; i <　10; i++) {
　　　　　　　　out.println("Wert bei: ");　+　i　+　" = ";　+　list[i];
　　　　　　}
　　　　} catch (IndexOutOfBoundsException e1) {
　　　　　　System.out.println("IndexOutOfBoundsException => ");　+　e1.getMessage());
　　　　} catch (IOException e2) {
　　　　　　System.out.println("IOException => ");　+　e2.getMessage());
　　　　} finally {
　　　　　　//Überprüfen Sie, ob der PrintWriter geöffnet ist
　　　　　　if (out != null) {
　　　　　　　　System.out.println("PrintWriter schließen");
　　　　　　　　out.close();
　　　　　　} else {
　　　　　　　　System.out.println("PrintWriter kann nicht geöffnet werden");
　　　　　　}
　　　　}
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　ListOfNumbers list = new ListOfNumbers();
　　　　list.writeList();
　　}
}

Bei der Ausführung dieses Programms können zwei Möglichkeiten auftreten:

1. Ausnahmefall im try-Block

2. try-Block wird normal ausgeführt

Bei der Erstellung eines neuen FileWriter kann ein Ausnahmefall auftreten. Wird das angegebene Datei nicht erstellt oder geschrieben, wird IOException ausgelöst.

Wenn ein Ausnahmefall auftritt, erhalten wir die folgenden Ausgaben.

Eingang in das try-Statement
IOException => OutputFile.txt
PrintWriter kann nicht geöffnet werden

Wenn keine Ausnahme auftritt und der try-Block normal ausgeführt wird, erhalten wir die folgenden Ausgaben.

Eingang in das try-Statement
PrintWriter schließen

Es wird eine OutputFile.txt erstellt und enthält folgenden Inhalt

Value at: 0 = 0
Value at:　1　=　1
Value at:　2　=　2
Value at:　3　=　3
Value at:　4　=　4
Value at:　5　=　5
Value at:　6　=　6
Value at:　7　=　7
Value at:　8　=　8
Value at:　9　=　9

try ... catch ... finally detaillierter Ablauf

Lassen Sie uns den Ablauf der Ausnahmebehandlung im obigen Beispiel näher untersuchen.

Das Diagramm beschreibt den Ablauf des Programms, wenn eine Ausnahme beim Erstellen eines neuen FileWriter auftritt.

• Um das Methoden, die die Ausnahme verursacht haben, zu finden, ruft der Hauptmethod writeList() auf, die dann die Methode FileWriter() aufruft, um eine neue OutputFile.txt zu erstellen.

• Wenn eine Ausnahme auftritt, überspringt das Laufzeitssystem den Rest des Codes im try-Block.

• Es beginnt, den Aufrufstapel in umgekehrter Reihenfolge zu durchsuchen, um den geeigneten Ausnahmebehandler zu finden.

• Hier hat der FileWriter keinen Ausnahmebehandler, daher überprüft das System bei der Laufzeit das nächste Verfahren im Aufrufstapel, nämlich writeList.

• Die Methode writeList hat zwei Ausnahmebehandler: einen für IndexOutOfBoundsException und einen für IOException.

• Dann behandelt das System diese Handler nacheinander.

• Der erste Handler in diesem Beispiel behandelt den IndexOutOfBoundsException. Dies stimmt nicht mit dem IOException, das im try-Block ausgelöst wurde, überein.

• Daher wird überprüft, welche IOException-Handler der nächste ist. Wenn er mit dem ausgelösten Ausnultipartyp übereinstimmt, wird der Code im entsprechenden catch-Block ausgeführt.

• Nach der Ausführung des Ausnahmebehandlungsprogramms wird der finally-Block ausgeführt.

• In diesem Szenario wurde keine Ausnahme im FileWriter aufgetreten, daher wurde das PrintWriter-Objekt out nie geöffnet und muss nicht geschlossen werden.

Lassen Sie uns nun annehmen, dass beim Ausführen des Programms keine Ausnahme aufgetreten ist und der try-Block normal ausgeführt wird. In diesem Fall wird eine OutputFile.txt erstellt und geschrieben.

Es ist bekannt, dass die Ausführung des finally-Blocks unabhängig von der Ausnahmebehandlung ist. Da keine Ausnahme aufgetreten ist, wurde PrintWriter geöffnet und muss geschlossen werden. Dies wird durch den Befehl out.close() im finally-Block erreicht.

Mehrere Ausnahmen fangen

Ab Java SE 7Ab der höheren Version können wir ab sofort mit einem catch-Block mehrere Ausnahmearten fangen.

Dies verringert die Code-Duplikation und verbessert die Einfachheit und Effizienz des Codes.

Jede Art von Ausnahme, die von einem catch-Block behandelt werden kann, wird durch einen vertikalen Strich (|) getrennt.

Die Syntax ist:

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

Für weitere Informationen besuchen Sie bitteJava erwischt mehrere Ausnahmen.

try-mit-resources-Anweisung

try-mit-resources-Anweisung ist ein try-Anweisung, die eine oder mehrere Ressourcenklärungen hat.

Die Syntax ist:

try (resource Declaration) {
　　//　Verwendung der Ressource
} catch (ExceptionType e1) {
　　//　catch-Block
}

Ressourcen sind Objekte, die am Ende des Programms geschlossen werden müssen. Sie müssen in der try-Anweisung deklariert und initialisiert werden.

Lassen Sie uns ein Beispiel nennen.

try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt"))) {
　　//　Verwendung der Ressource
}

try-mit-resources-Anweisung wird auch alsAutomatische Ressourcenverwaltung. Diese Anweisung schließt alle Ressourcen automatisch am Ende der Anweisung ab.

Für weitere Informationen besuchen Sie bitteJava try-mit-resources-Anweisung.