Java Exception Handling

6 Kernkonzepte

Die wichtigsten Konzepte der Java-Exception-Behandlung: try / catch · finally · throw · throws · Checked / Unchecked · try-with-resources Exception Handling ist in Java ein zentrales Konzept für die Fehlerbehandlung. Es ermöglicht die kontrollierte Reaktion auf Laufzeitfehler und die Gewährleistung der Programmstabilität.

try / catch – Exceptions abfangen

try { ... } catch (Exception e) { ... }

try { int[] arr = new int[5]; arr[10] = 42; // ArrayIndexOutOfBoundsException } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Index-Fehler: " + e.getMessage()); }

try-catch fängt Exceptions ab und verhindert, dass das Programm abstürzt. Der try-Block enthält den gefährdeten Code, der catch-Block behandelt die Exception.

Wichtige Exception-Klassen

Exception	Beschreibung
Exception	Oberklasse aller Exceptions (checked)
RuntimeException	Oberklasse aller unchecked Exceptions
NullPointerException	Zugriff auf null-Referenz
ArrayIndexOutOfBoundsException	Ungültiger Array-Index
IllegalArgumentException	Ungültiges Methodenargument
IOException	Ein-/Ausgabe-Fehler (checked)
ClassNotFoundException	Klasse nicht gefunden (checked)
SQLException	Datenbank-Fehler (checked)

Beispiele

try {

int x = 10 / 0; // ArithmeticException

String s = null;

s.length(); // NullPointerException

} catch (ArithmeticException e) {

System.out.println("Arithmetik-Fehler: " + e.getMessage());

} catch (NullPointerException e) {

System.out.println("Null-Zugriff: " + e.getMessage());

} catch (Exception e) { // Alle anderen fangen

System.out.println("Allgemeiner Fehler: " + e.getMessage());

}

// Multi-Catch (Java 7+)

catch (ArithmeticException | NullPointerException e) {

System.out.println("Arithmetik oder Null: " + e.getMessage());

}

Tipp: Fangen Sie Exceptions so spezifisch wie möglich ab – zuerst die spezifischen, dann die allgemeineren. Verwenden Sie Multi-Catch für ähnliche Exception-Typen.

finally – Immer ausführen

finally { ... }

try { // Code, der eine Exception werfen könnte } catch (Exception e) { // Exception behandeln } finally { // Wird immer ausgeführt (auch bei Exception) }

finally wird immer ausgeführt – unabhängig davon, ob eine Exception aufgetreten ist oder nicht. Es wird typischerweise für Aufräumarbeiten (z.B. Schließen von Ressourcen) verwendet.

Beispiele

FileInputStream file = null;

try {

file = new FileInputStream("test.txt");

// Datei lesen...

} catch (FileNotFoundException e) {

System.out.println("Datei nicht gefunden");

} finally {

if (file != null) {

try { file.close(); }

catch (IOException e) { /* ignorieren */ }

}

Tipp: Für die automatische Ressourcenverwaltung verwenden Sie try-with-resources (ab Java 7) – das ist kürzer und sicherer als finally.

throw – Exception werfen

throw new Exception("Nachricht");

throw new IllegalArgumentException("Ungültiger Wert");

throw wirft explizit eine Exception. Sie können sowohl Standard-Exceptions als auch eigene Exception-Klassen werfen.

Beispiele

public static int divide(int a, int b) {

if (b == 0) {

throw new ArithmeticException("Division durch 0 nicht erlaubt");

}

return a / b;

}

// Eigene Exception

class MyException extends Exception {

public MyException(String msg) { super(msg); }

}

public void check(int value) throws MyException {

if (value < 0) {

throw new MyException("Negativer Wert: " + value);

}

Tipp: Werfen Sie Exceptions frühzeitig, um Fehlerzustände klar zu signalisieren. Verwenden Sie eigene Exception-Klassen für fachspezifische Fehler.

throws – Exception deklarieren

throws Exception · throws IOException, SQLException

public void readFile(String path) throws IOException { // Methode, die eine IOException werfen kann }

throws deklariert, dass eine Methode eine oder mehrere Exceptions werfen kann. Aufrufer müssen diese Exceptions entweder selbst behandeln oder weiterdeklarieren.

Wichtige Regeln

Regel	Beschreibung
Checked Exceptions	Müssen deklariert oder abgefangen werden (IOException, SQLException, ...)
Unchecked Exceptions	Müssen nicht deklariert werden (RuntimeException, NullPointerException, ...)
Mehrere Exceptions	Können mit Komma getrennt werden: `throws IOException, SQLException`
Vererbung	Eine überschriebene Methode darf nur Exception-Typen deklarieren, die weniger oder gleich spezifisch sind

Beispiele

// Methode mit throws-Deklaration

public static void readFile(String path) throws FileNotFoundException {

FileInputStream file = new FileInputStream(path);

// ...

}

// Aufruf – entweder try-catch:

try {

readFile("test.txt");

} catch (FileNotFoundException e) {

System.out.println("Datei nicht gefunden");

}

// Oder weiterdeklarieren:

public static void main(String[] args) throws FileNotFoundException {

readFile("test.txt");

}

Tipp: Deklarieren Sie möglichst spezifische Exceptions (throws IOException statt throws Exception), um dem Aufrufer mehr Informationen zu geben.

Checked vs Unchecked – Exception-Typen

Checked: Exception · Unchecked: RuntimeException

// Checked (Compiler zwingt zur Behandlung) try { new FileInputStream("file.txt"); } catch (FileNotFoundException e) { } // Unchecked (keine Behandlung erforderlich) int x = 10 / 0; // ArithmeticException (unchecked)

Checked Exceptions müssen zur Compile-Zeit behandelt werden (try-catch oder throws). Unchecked Exceptions (RuntimeException) müssen nicht behandelt werden.

Unterschiede im Überblick

Eigenschaft	Checked Exception	Unchecked Exception
Basisklasse	Exception (außer RuntimeException)	RuntimeException
Behandlung	try-catch oder throws erforderlich	Nicht erforderlich (optional)
Prüfung	Zur Compile-Zeit	Zur Laufzeit
Beispiele	IOException, SQLException, ClassNotFoundException	NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException
Wann verwenden	Bei erwartbaren, behebbaren Fehlern	Bei Programmfehlern (nicht behebbar)

Beispiele

// Checked Exception – muss behandelt werden

try {

Thread.sleep(1000); // InterruptedException (checked)

} catch (InterruptedException e) {

e.printStackTrace();

}

// Unchecked Exception – Behandlung optional

String s = null;

s.length(); // NullPointerException (unchecked)

// Eigene Exception – entweder checked oder unchecked

class MyCheckedException extends Exception { } // checked

class MyUncheckedException extends RuntimeException { } // unchecked

Tipp: Verwenden Sie Checked Exceptions für Fehler, von denen Sie erwarten, dass der Aufrufer sie behandeln kann (z.B. Datei nicht gefunden). Unchecked Exceptions sind für Programmierfehler gedacht (z.B. null-Referenz).

try-with-resources – Automatische Ressourcenverwaltung

try (Resource r = new Resource()) { ... }

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) { String line = br.readLine(); } catch (IOException e) { e.printStackTrace(); } // br wird automatisch geschlossen

try-with-resources (ab Java 7) schließt Ressourcen automatisch, die das Interface AutoCloseable implementieren. Die Ressourcen werden in umgekehrter Reihenfolge ihrer Deklaration geschlossen.

AutoCloseable Klassen

Klasse	Beschreibung
FileInputStream	Datei-Eingabestrom
FileOutputStream	Datei-Ausgabestrom
BufferedReader	Pufferleser
BufferedWriter	Pufferschreiber
Connection (JDBC)	Datenbankverbindung
Statement (JDBC)	SQL-Statement
ResultSet (JDBC)	SQL-Ergebnismenge
Scanner	Parser für Eingaben

Beispiele

// Mehrere Ressourcen

try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));

BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {

String line;

while ((line = br.readLine()) != null) {

bw.write(line + "\n");

}

} catch (IOException e) {

e.printStackTrace();

} // br und bw werden automatisch geschlossen

// Mit eigenem AutoCloseable

class MyResource implements AutoCloseable {

@Override

public void close() throws Exception {

System.out.println("Ressource geschlossen");

}

Tipp: try-with-resources ist die bevorzugte Methode für die Arbeit mit Dateien, Datenbanken und anderen Ressourcen, die geschlossen werden müssen – es ist kürzer und sicherer als try-finally.

Java Exception Handling im Überblick

try Gefährdeten Code ausführen
Mögliche Exceptions

catch Exception abfangen
Behandeln oder loggen

finally Immer ausführen
Aufräumen (z.B. close)

throw Exception werfen
Fehler signalisieren

throws Exception deklarieren
Methode kann Exception werfen

try-with Auto-closeable
Ressourcen automatisch schließen

Quick Summary

try

Gefährdeter Code

catch

Exception abfangen

finally

Immer ausführen

throw

Exception werfen

throws

Exception deklarieren

try-with

Auto-closeable

try { ... } catch (Exception e) { ... } · throw new Exception("msg"); · void m() throws IOException { ... }