Exception-Klassenhierarchie

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy — Lektion 59 von 87.

Javas Exception-Handling-System basiert auf einer gut organisierten Klassenhierarchie, die in der Klasse Throwable verwurzelt ist. Das Verständnis dieser Hierarchie hilft Ihnen dabei, Exceptions effektiver abzufangen und zu behandeln.

An der Spitze steht Throwable, die Basisklasse aller Exceptions und Errors. Sie hat zwei direkte Unterklassen:

Throwable
├── Error          // Schwerwiegende Probleme (diese nicht abfangen)
└── Exception      // Behebbare Probleme
    └── RuntimeException  // Ungeprüfte Exceptions

Error repräsentiert schwerwiegende Probleme, die Anwendungen nicht versuchen sollten zu behandeln – wie OutOfMemoryError oder StackOverflowError. Diese weisen auf grundlegende Probleme mit der JVM selbst hin.

Exception ist der Zweig, mit dem Sie am häufigsten arbeiten werden. Er unterteilt sich in zwei Kategorien: geprüfte Ausnahmen (direkte Unterklassen von Exception) und ungeprüfte Ausnahmen (Unterklassen von RuntimeException).

// Gängige Exception-Klassen
Exception
├── IOException           // Datei-/Netzwerkprobleme
├── SQLException          // Datenbankprobleme
└── RuntimeException
    ├── NullPointerException
    ├── ArrayIndexOutOfBoundsException
    └── IllegalArgumentException

Da Exceptions Klassen sind, folgen sie Vererbungsregeln. Wenn Sie einen übergeordneten Exception-Typ abfangen, fangen Sie auch alle seine untergeordneten Typen ab:

try {
    // etwas Code
} catch (Exception e) {
    // Fängt ALLE Exceptions ab (normalerweise zu allgemein)
}

try {
    // einiger Code
} catch (RuntimeException e) {
    // Fängt nur Runtime-Exceptions und Unterklassen ab
}

Diese Hierarchie ermöglicht es Ihnen, bei der Fehlerbehandlung so spezifisch oder allgemein wie nötig zu sein, und sie ist die Grundlage für die Erstellung Ihrer eigenen benutzerdefinierten Ausnahmen.

Aufgabe

Einfach

Lassen Sie uns einen Exception-Analyzer bauen, der zeigt, wie die Exception-Hierarchie in Java in der Praxis funktioniert! Sie werden ein System erstellen, das Ausnahmen auf verschiedenen Spezifitätsebenen abfängt und berichtet, welcher Typ abgefangen wurde.

Sie werden Ihren Code über drei Dateien organisieren:

ExceptionThrower.java: Erstellen Sie eine Klasse, die basierend auf der Eingabe verschiedene Arten von Ausnahmen auslösen kann. Ihre Klasse sollte drei statische Methoden haben:
triggerRuntime(String type) - Lösen Sie basierend auf dem Typ-String verschiedene Runtime-Exceptions aus:
- Wenn der Typ "null" ist, werfen Sie eine NullPointerException mit der Nachricht "Null value encountered"
- Wenn der Typ "index" ist, werfen Sie eine ArrayIndexOutOfBoundsException mit der Nachricht "Invalid index"
- Wenn der Typ "argument" ist, werfen Sie eine IllegalArgumentException mit der Nachricht "Bad argument"
triggerArithmetic() - Werfen Sie eine ArithmeticException mit der Nachricht "Division error"

triggerGeneric() - Werfen Sie eine IllegalStateException mit der Nachricht "Generic runtime error" (ihre Hierarchie ist Exception > RuntimeException > IllegalStateException)
ExceptionAnalyzer.java: Erstellen Sie eine Klasse, die Ausnahmen auf verschiedenen Hierarchieebenen abfängt und identifiziert, was abgefangen wurde. Fügen Sie diese statischen Methoden hinzu:
analyzeSpecific(String type) - Rufen Sie ExceptionThrower.triggerRuntime(type) innerhalb eines try-Blocks auf. Verwenden Sie separate catch-Blöcke für NullPointerException, ArrayIndexOutOfBoundsException und IllegalArgumentException. Geben Sie für jeden aus: Caught specific: [exception class simple name] gefolgt von Message: [exception message]

analyzeWithParent() - Rufen Sie ExceptionThrower.triggerArithmetic() innerhalb eines try-Blocks auf. Fangen Sie diese mit RuntimeException (dem Elterntyp) ab. Geben Sie aus: Caught via parent: RuntimeException gefolgt von Actual type: [exception class simple name]

analyzeWithGrandparent() - Rufen Sie ExceptionThrower.triggerGeneric() innerhalb eines try-Blocks auf. Fangen Sie diese mit Exception (noch höher in der Hierarchie) ab. Geben Sie aus: Caught via grandparent: Exception gefolgt von Actual type: [exception class simple name]
Main.java: Bringen Sie Ihren Exception-Analyzer zusammen! Sie erhalten eine Eingabe: einen Exception-Typ-String (entweder "null", "index" oder "argument").
Geben Sie zuerst === Specific Catch === aus und rufen Sie analyzeSpecific mit Ihrer Eingabe auf.

Geben Sie dann eine Leerzeile und === Parent Catch === aus und rufen Sie analyzeWithParent auf.

Geben Sie schließlich eine Leerzeile und === Grandparent Catch === aus und rufen Sie analyzeWithGrandparent auf.

Sie erhalten eine Eingabe: den auszulösenden Exception-Typ ("null", "index" oder "argument").

Verwenden Sie e.getClass().getSimpleName(), um den Klassennamen der Exception zu erhalten, und e.getMessage(), um deren Nachricht abzurufen. Diese Herausforderung zeigt, wie das Abfangen eines Eltern-Exception-Typs auch alle seine Kinder abfängt – ein Schlüsselkonzept bei der Entscheidung, wie spezifisch Ihre Fehlerbehandlung sein sollte!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String type = scanner.nextLine();
        
        // TODO: "=== Specific Catch ===" ausgeben und ExceptionAnalyzer.analyzeSpecific(type) aufrufen
        
        // TODO: Eine Leerzeile ausgeben, dann "=== Parent Catch ===", dann ExceptionAnalyzer.analyzeWithParent() aufrufen
        
        // TODO: Eine Leerzeile ausgeben, dann "=== Grandparent Catch ===", dann ExceptionAnalyzer.analyzeWithGrandparent() aufrufen
    }
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

1Grundlagen der OOP

Externe Dateien Einführung in die OOP Klassen vs. Objekte Das this-Schlüsselwort Methoden Felder (Attribute)Konstruktor-Methode Konstruktor-Überladung Rückblick – Einfacher Taschenrechner

4Vererbung

Grundlagen der Vererbung (extends)Das super-Schlüsselwort Methoden überschreiben (@Override)Konstruktor-Verkettung Die Object-Klasse Einfache & mehrstufige Vererbung Warum keine Mehrfachvererbung von Klassen Zusammenfassung - Mitarbeiter-Hierarchie

7Spezielle Methoden & Object-Klasse

toString()-Methode equals() und hashCode()clone()-Methode compareTo() und Comparable Comparator-Interface Zusammenfassung – Benutzerdefiniertes Sortieren

10Ausnahmebehandlung in OOP

Exception-KlassenhierarchieBenutzerdefinierte Exceptions Checked vs. Unchecked Errors Try-With-Resources-Pattern Recap – Validierter Benutzer

13Projekt: Bibliotheksverwaltung

Projektübersicht & UML-Design Buch- und Benutzerklassen Ausleihsystem Suchfunktionalität Admin-Interface Integration von Exception Handling Testen und Integration