Das Erstellen benutzerdefinierter Java-Ausnahmen

Einführung

In Java werden Ausnahmen geworfen, um außergewöhnliche Ereignisse anzuzeigen, die während der Ausführung eines Programms auftreten. Während Java eine Reihe von eingebauten Ausnahmen bietet, müssen wir manchmal eigene benutzerdefinierte Ausnahmen für spezifische Situationen definieren. Es gibt zwei Arten von benutzerdefinierten Ausnahmen: geprüfte und unprüfte Ausnahmen. Geprüfte Ausnahmen sind diejenigen, die während der Kompilierung behandelt werden müssen, während unprüfte Ausnahmen nur zur Laufzeit erkannt werden. In diesem Lab werden wir beide Arten von benutzerdefinierten Ausnahmen erstellen und lernen, wie wir sie verwenden.

Erstellen einer Java-Klasse namens MyArray

Zunächst werden wir eine Java-Klasse namens MyArray erstellen, um ein Array mit der get()-Methode zu implementieren, die eine Ausnahme werfen kann, wenn der Index ungültig ist.

public class MyArray {
    int[] array;

    public MyArray(int size) {
        array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i * 5;
        }
    }

    // Get-Methode, die eine Ausnahme werfen kann
    public int get(int index) {
        if (index >= array.length) {
            throw new IndexOutOfBoundsException("Index " + index + " ist ungültig.");
        } else {
            return array[index];
        }
    }
}

Erstellen einer benutzerdefinierten geprüften Ausnahme

Wir können eine benutzerdefinierte geprüfte Ausnahme erstellen, indem wir die Exception-Klasse erweitern. In diesem Beispiel werden wir eine IndexNotValidException erstellen, wenn der Index ungültig ist. Diese Ausnahme wird von der get()-Methode in der MyArray-Klasse geworfen.

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

Wir können nun die get()-Methode in der MyArray-Klasse aktualisieren, um diese benutzerdefinierte Ausnahme zu werfen.

public int get(int index) throws IndexNotValidException {
    if (index >= array.length) {
        throw new IndexNotValidException("Index " + index + " ist ungültig.");
    } else {
        return array[index];
    }
}

Behandeln der benutzerdefinierten geprüften Ausnahme

Um die benutzerdefinierte geprüfte Ausnahme zu behandeln, müssen wir sie fangen oder sie mit dem Schlüsselwort throws deklarieren, wenn die get()-Methode in der Demo-Klasse aufgerufen wird.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        try {
            System.out.println(arr.get(10)); // Wirft IndexNotValidException
        } catch (IndexNotValidException e) {
            System.err.println(e.getMessage());
        }
    }
}

Erstellen einer benutzerdefinierten unprüfenden Ausnahme

Wir können eine benutzerdefinierte unprüfende Ausnahme erstellen, indem wir die RuntimeException-Klasse erweitern, anstatt die Exception-Klasse. Im folgenden Beispiel werden wir eine IndexNotValidRuntimeException erstellen, wenn der Index ungültig ist, die von der get()-Methode in der MyArray-Klasse geworfen wird.

public class IndexNotValidRuntimeException extends RuntimeException {
    public IndexNotValidRuntimeException(String message, Throwable cause) {
        super(message, cause);
    }
}

Zusätzlich definieren wir eine auslösbare Ausnahme, die die zugrunde liegende Ausnahme oder die Ursache unserer Ausnahme definiert. Im Falle von uns ist die zugrunde liegende Ausnahme ArrayIndexOutOfBounds. Wir können die get()-Methode in der MyArray-Klasse aktualisieren, um die benutzerdefinierte unprüfende Ausnahme zu werfen.

public int get(int index) {
    if (index >= array.length) {
        Throwable cause = new ArrayIndexOutOfBoundsException();
        throw new IndexNotValidRuntimeException("Index " + index + " ist ungültig.", cause);
    } else {
        return array[index];
    }
}

Behandle die benutzerdefinierte unprüfende Ausnahme

Wir müssen die benutzerdefinierte unprüfende Ausnahme nicht fangen oder deklarieren. Im folgenden Beispiel wird, wenn die get()-Methode in der Demo-Klasse mit einem ungültigen Index aufgerufen wird, eine IndexNotValidRuntimeException geworfen.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        System.out.println(arr.get(10)); // Wirft IndexNotValidRuntimeException
    }
}

Zusammenfassung

Benutzerdefinierte Java-Ausnahmen können uns helfen, spezifische Fehler oder Ausnahmen in unserer Anwendung effektiv zu behandeln, indem wir Ausnahmen erstellen, die unseren Anforderungen angepasst sind. In diesem Lab haben wir gelernt, wie wir unsere eigenen benutzerdefinierten Ausnahmen erstellen, um Fehler in unserer Geschäftslogik oder unserem Workflow zu behandeln. Wir haben auch diskutiert, wie sowohl geprüfte als auch unprüfende Ausnahmen erstellt werden können, mit Beispielen für jede.