Exception Handling in Java - Grundlagen und Best Practices

Java • 15. Februar 2025 • Lesezeit: 4 Minuten

Exception Handling ist ein wichtiger Bestandteil der (Java)-Programmierung da Fehler und Unerwartetes jederzeit auftreten kann. Ein gutes Exception Handling stellt in solchen Fällen sicher, dass Programme stabil und benutzerfreundlich bleiben. In diesem Beitrag erkläre ich, was Exceptions sind und wie wir sie in Java einsetzen können.

Was sind Exceptions?

Ganz grundsätzlich lässt sich sagen, dass eine Exception ein unerwartetes Ereignis ist, das während der Programmausführung auftritt und den normalen Ablauf unterbricht.

In Java gibt es zwei Hauptkategorien von Exceptions: Checked und Unchecked Exceptions.

Checked Exceptions müssen explizit behandelt oder deklariert werden (z.B. IOException) während Unchecked Exceptions nicht zwingend behandelt werden müssen (z.B. NullPointerException).

Exception Handling mit try, catch und finally

Java bietet verschiedene Schlüsselwörter zur Behandlung von Exceptions:

• try: Enthält den Code, der möglicherweise eine Exception auslöst.
• catch: Fängt eine Exception ab und verarbeitet sie.
• finally: Enthält Code, der unabhängig vom Auftreten einer Exception immer ausgeführt wird.

Beispiel: Division durch 0 vermeiden

Hier ist ein einfaches Beispiel, das zeigt, wie eine Exception abgefangen wird:

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Ergebnis: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Fehler: Division durch 0 ist nicht erlaubt!");
        } finally {
            System.out.println("Berechnung abgeschlossen.");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Eine Division durch 0 ist nicht möglich und würde hier zu einer ArithmeticException führen. Deswegen führen wir den Versuch in einem try-Block durch. Kommt es tatsächlich zu einer Exception, wird an der Stelle der try-Block verlassen, an dem die Exception auftritt. Dadurch, dass wir die Exception im catch-Block fangen (engl. to catch), landen wir direkt dort. Der finally-Block wird hingegen immer ausgeführt - ob eine Exception auftritt oder nicht. Der finally-Block ist optional, muss also nicht definiert werden, wenn man ihn nicht benötigt.

Wir fangen hier explizit eine ArithmeticException und nur wenn diese auch geworfen wird, landen wir in unserem catch-Block. Andere Exceptions die auftreten könnten, werden hier nicht gefangen.

Eigene Exceptions definieren

Manchmal ist es sinnvoll, eigene Exceptions zu definieren. Dazu erstellt man eine Klasse, die von Exception erbt:

class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            checkNumber(-1);
        } catch (CustomException e) {
            System.out.println("Fehler: " + e.getMessage());
        }
    }

    public static void checkNumber(int number) throws CustomException {
        if (number < 0) {
            throw new CustomException("Negative Zahlen sind nicht erlaubt!");
        }
        System.out.println("Zahl ist gültig: " + number);
    }
}

Wie du sehen kannst, kann es durchaus nützlich sein, eigene Exceptions zu definieren die zu deiner Verarbeitung und deiner Geschäftslogik passen. Grundsätzlich ist ein sauberes Exception Handling essenziell für stabilde Anwendungen. Es hilft dabei, Fehler sinnvoll zu behandeln, anstatt das Programm abstürzen zu lassen. Durch eigene Exceptions kannst du auch spezifische Fehlerfälle besser abbilden und die Wartbarkeit und Übersichtlichkeit deines Codes verbessern.

Ich hoffe sehr, dass dir dieses kleine Beispiel geholfen hat zu verstehen, wie man Exception Handling bestmöglichst einsetzt und die auftretende Exception fängt falls sie auftritt.

Hast du selbst schon Erfahrungen im Exception Handling gesammelt? Lass es mich gern in den Kommetaren wissen.