Fehlerbehandlung

In echten Programmen läuft selten alles perfekt.
Daten fehlen, Dateien sind nicht da, Eingaben sind ungültig, Netzwerkverbindungen brechen ab.

Wenn du nichts dagegen tust, stürzt das Programm ab — mit einer Exception (engl. „Ausnahme“).

Java gibt dann eine Fehlermeldung und einen Stacktrace aus, z. B.:

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Main.main(Main.java:4)

Das Ziel der Fehlerbehandlung ist also:

Fehler vorhersehen oder abfangen,
sinnvoll reagieren,
und das Programm stabil weiterlaufen lassen.

Was ist eine Exception?

Eine Exception ist ein Objekt, das beschreibt, dass ein Fehler aufgetreten ist.

Typ	Beispiel	Bedeutung
`ArithmeticException`	Division durch 0	Mathematischer Fehler
`NullPointerException`	Zugriff auf nicht existierendes Objekt	häufigster Fehler überhaupt
`ArrayIndexOutOfBoundsException`	Zugriff außerhalb eines Arrays	Indexfehler
`IOException`	Datei nicht gefunden oder fehlerhaft	Input/Output-Fehler

Wenn eine Exception „geworfen“ wird,
springt Java aus der aktuellen Methode heraus,
bis eine passende try–catch-Behandlung gefunden wird.

`try` – `catch` – `finally`

Grundstruktur:

try {
    // Code, der fehleranfällig ist
} catch (Exceptiontyp e) {
    // Code, der ausgeführt wird, wenn ein Fehler passiert
} finally {
    // optional: wird immer ausgeführt (z. B. Aufräumen)
}

Beispiel:

public class Main {
    public static void main(String[] args) {
        try {
            int zahl = 10 / 0; // Fehler!
            System.out.println("Ergebnis: " + zahl);
        } catch (ArithmeticException e) {
            System.out.println("Fehler: Division durch 0 ist nicht erlaubt.");
        } finally {
            System.out.println("Programm wurde beendet.");
        }
    }
}

Ausgabe:

Fehler: Division durch 0 ist nicht erlaubt.
Programm wurde beendet.

Mehrere `catch`-Blöcke

Du kannst auf verschiedene Fehlertypen unterschiedlich reagieren:

try {
    int[] zahlen = {1, 2, 3};
    System.out.println(zahlen[5]); // Fehler: Index 5 gibt’s nicht
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index ungültig!");
} catch (Exception e) {
    System.out.println("Allgemeiner Fehler: " + e.getMessage());
}

Wichtig:
Die Reihenfolge ist entscheidend –
immer vom spezielleren zum allgemeineren Exception-Typ.

Eigene Exceptions werfen (`throw`)

Du kannst auch eigene Fehler manuell auslösen,
wenn du erkennst, dass etwas nicht stimmt.

public class Konto {
    private double kontostand = 100;

    public void abheben(double betrag) {
        if (betrag > kontostand) {
            throw new IllegalArgumentException("Nicht genug Guthaben!");
        }
        kontostand -= betrag;
    }
}

Verwendung:

try {
    Konto k = new Konto();
    k.abheben(200);
} catch (IllegalArgumentException e) {
    System.out.println("Fehler: " + e.getMessage());
}

Ausgabe:

Fehler: Nicht genug Guthaben!

Eigene Exception-Klasse definieren

Manchmal willst du klarere Fehlertypen schaffen, z. B. für dein eigenes Projekt:

public class ZuWenigGuthabenException extends Exception {
    public ZuWenigGuthabenException(String msg) {
        super(msg);
    }
}

Verwendung:

public class Konto {
    private double kontostand = 100;

    public void abheben(double betrag) throws ZuWenigGuthabenException {
        if (betrag > kontostand) {
            throw new ZuWenigGuthabenException("Saldo zu niedrig: " + kontostand);
        }
        kontostand -= betrag;
    }
}

Wichtig:
Da diese Exception „geprüft“ ist (checked exception),
muss die Methode throws angeben und der Aufrufer try–catch nutzen.

`checked` vs. `unchecked` Exceptions

Kategorie	Klasse	Behandlung notwendig?	Beispiel
checked	erbt von `Exception` (nicht von `RuntimeException`)	Ja – muss mit `try–catch` oder `throws` behandelt werden	`IOException`, `SQLException`
unchecked	erbt von `RuntimeException`	Nein – optional	`NullPointerException`, `IllegalArgumentException`

Merksatz:

Checked → vorhersehbare Fehler (Datei fehlt, Verbindung getrennt)
Unchecked → Programmierfehler (vergessenes null, falscher Index)

Beispiel: Kombination aus try–catch und finally

public class DateiLesen {
    public static void main(String[] args) {
        java.io.FileReader reader = null;
        try {
            reader = new java.io.FileReader("daten.txt");
            int zeichen;
            while ((zeichen = reader.read()) != -1) {
                System.out.print((char) zeichen);
            }
        } catch (java.io.FileNotFoundException e) {
            System.out.println("Datei nicht gefunden!");
        } catch (java.io.IOException e) {
            System.out.println("Fehler beim Lesen!");
        } finally {
            try {
                if (reader != null) reader.close();
            } catch (java.io.IOException e) {
                System.out.println("Fehler beim Schließen der Datei.");
            }
        }
    }
}

Der finally-Block wird immer ausgeführt –
selbst wenn im try– oder catch-Block ein Fehler auftritt.
Perfekt für Aufräumarbeiten (z. B. Datei schließen, Verbindung trennen).

Interaktive Visualisierung: try–catch in Aktion

Diese Mini-Simulation zeigt, was passiert, wenn ein Fehler auftritt
und wie das Programm reagiert, sobald ein try–catch aktiv ist.

Interaktive Visualisierung: try–catch

– Ausgabe der Java-Konsole –

Häufige Fehlerquellen

Fehler	Ursache	Lösung
`Unhandled exception`	Checked Exception nicht behandelt	try–catch oder `throws` hinzufügen
`finally` wird nicht ausgeführt	Programm wurde vorher beendet	Niemals `System.exit()` im try–Block verwenden
Falsche Reihenfolge der catch-Blöcke	`Exception` vor spezifischem Typ	Immer vom speziellsten zum allgemeinsten
Keine sinnvolle Fehlermeldung	e.getMessage() fehlt	In catch-Block aussagekräftige Infos ausgeben

Fehlerbehandlung

Was ist eine Exception?

try – catch – finally

Mehrere catch-Blöcke

Eigene Exceptions werfen (throw)

Eigene Exception-Klasse definieren

checked vs. unchecked Exceptions