# Fehlerbehandlung mit Exceptions

> Eine Exception ist ein Ausnahmefehler zur Laufzeit, etwa eine fehlende Datei oder eine Division durch null. Statt das Programm abstürzen zu lassen, fängt man Exceptions mit try-catch ab: Der riskante Code steht im try-Block, die Reaktion im catch-Block, und ein optionaler finally-Block läuft immer. So bleibt das Programm kontrollierbar.

**Autor:** Mr. Benjamin · **Beruf:** IT-Grundlagen
**Veröffentlicht:** 2026-09-22 · **Aktualisiert:** 2026-09-22
**Quelle:** https://yellowbluetech.de/blog/fehlerbehandlung-exceptions

---

Eine Datei fehlt, das Netzwerk ist weg, der Nutzer tippt Buchstaben statt Zahlen – solche Fehler lassen sich nicht immer verhindern. Der Unterschied zwischen guter und schlechter Software liegt darin, **wie** sie damit umgeht. Genau dafür gibt es Exceptions.

## Was ist eine Exception?

Eine Exception (Ausnahme) ist ein **Fehler zur Laufzeit**, der den normalen Programmablauf unterbricht. Wird sie nicht behandelt, stürzt das Programm ab.

Typische Beispiele:
- Zugriff auf eine **nicht vorhandene Datei**
- **Division durch null**
- Umwandlung von `"abc"` in eine Zahl
- Zugriff auf ein Listenelement, das es nicht gibt

> **Merksatz**
>
> Man unterscheidet **Fehler abfangen** von **Fehler ignorieren**. Eine unbehandelte Exception beendet das Programm; eine abgefangene erlaubt eine kontrollierte Reaktion – etwa eine verständliche Meldung statt eines Absturzes.

## try – catch – finally

Der riskante Code kommt in den `try`-Block. Tritt dort eine Exception auf, springt das Programm in den `catch`-Block. Der `finally`-Block läuft **in jedem Fall** – ob Fehler oder nicht.

```text
try {
    zahl = leseEingabe()        // könnte fehlschlagen
    ergebnis = 100 / zahl       // Division durch null?
} catch (Fehler e) {
    zeige "Bitte gültige Zahl eingeben"
} finally {
    schließeEingabe()           // läuft immer
}
```

| Block | Zweck | Läuft wann? |
| --- | --- | --- |
| `try` | riskanter Code | immer (Einstieg) |
| `catch` | Reaktion auf den Fehler | nur bei Exception |
| `finally` | Aufräumen (z. B. Datei schließen) | **immer** |

> **Prüfungstipp**
>
> Merke: Der **`finally`-Block läuft immer** – auch wenn im try-Block ein `return` steht oder eine Exception fliegt. Deshalb gehört dort das **Aufräumen** hinein (Datei/Verbindung schließen). Ein zweiter beliebter Punkt: Fange Exceptions **so konkret wie möglich** ab; ein pauschales „fange alles" verschleiert echte Programmierfehler.

## Nicht jeden Fehler abfangen

> **Hinweis**
>
> Exceptions sind für **erwartbare Ausnahmesituationen** gedacht (Datei fehlt, Eingabe ungültig), nicht als Ersatz für saubere Logik. Einen Programmierfehler wie einen falschen Index sollte man **beheben**, nicht mit try-catch übertünchen. Auch stilles Verschlucken („catch, aber nichts tun") ist gefährlich, weil Fehler dann unbemerkt bleiben. Faustregel: abfangen, was man sinnvoll behandeln kann – und den Rest bewusst nach oben weitergeben. Wer Eingaben prüft, bevor er sie verarbeitet (siehe [Kontrollstrukturen](/blog/kontrollstrukturen-programmierung)), braucht ohnehin weniger Exceptions.

## Selbstkontrolle

**Frage:** Wann wird der finally-Block ausgeführt?

- [ ] Nur wenn kein Fehler auftrat
- [ ] Nur wenn eine Exception auftrat
- [x] Immer – mit und ohne Fehler
- [ ] Nur wenn kein catch vorhanden ist

**Erklärung:** Der finally-Block läuft immer – egal ob im try-Block alles glattging, eine Exception auftrat oder sogar ein return ausgeführt wurde. Deshalb ist er der richtige Ort für Aufräumarbeiten wie das Schließen einer Datei oder Verbindung.

## Häufige Fragen

### Was ist der Unterschied zwischen Fehler und Exception?

Umgangssprachlich meint man oft dasselbe. Genauer: Eine Exception ist ein Objekt, das einen Ausnahmezustand zur Laufzeit beschreibt und das man abfangen kann. Manche Sprachen trennen zusätzlich schwere, meist nicht behandelbare Fehler (etwa zu wenig Speicher) von normalen, behandelbaren Exceptions.

### Sollte man alle Exceptions abfangen?

Nein. Man fängt gezielt die ab, auf die man sinnvoll reagieren kann, etwa eine fehlende Datei mit einer Nutzermeldung. Ein pauschales Abfangen aller Fehler verdeckt echte Programmierfehler und erschwert die [Fehlersuche](/blog/systematische-fehlersuche). Was man nicht sinnvoll behandeln kann, gibt man bewusst weiter.

### Was bedeutet 'eine Exception werfen'?

Wenn ein Programmteil einen Fehlerzustand feststellt, kann er selbst eine Exception auslösen (werfen, throw), die dann weiter oben abgefangen wird. So trennt man das Erkennen eines Problems von seiner Behandlung. Eine eigene, aussagekräftige Exception ist oft klarer als ein kryptischer Rückgabewert.

### Was ist der Unterschied zu einer Validierung?

Validierung prüft Eingaben vorab, damit ein Fehler gar nicht erst entsteht, etwa ob ein Feld leer ist. Exceptions greifen, wenn trotz Prüfung zur Laufzeit etwas schiefgeht, das man nicht vollständig ausschließen kann, etwa ein Netzwerkabbruch. Beide ergänzen sich: erst validieren, dann für den Rest Exceptions einsetzen.

**Weiterlesen:** [Compiler vs. Interpreter: Unterschied erklärt](/blog/compiler-vs-interpreter) · [OOP-Grundlagen: Klasse, Objekt, Prinzipien](/blog/oop-grundlagen) · [Softwaretests: von Unit-Test bis Abnahme](/blog/softwaretests-grundlagen) · [Rekursion: wenn sich eine Funktion selbst aufruft](/blog/rekursion-erklaert)

## Das Wichtigste in Kürze

- Eine **Exception** ist ein **Laufzeitfehler**, der den Ablauf unterbricht.
- **try** = riskanter Code, **catch** = Reaktion, **finally** = läuft **immer** (Aufräumen).
- Exceptions **so konkret wie möglich** abfangen, nicht pauschal.
- Für **erwartbare** Ausnahmen gedacht – kein Ersatz für saubere Logik.
- Nicht **still verschlucken**: unbehandelte Fehler bleiben sonst unbemerkt.