Wie kann man eigene Exceptions deklarieren?

Die Ausnahmebehandlung mittels Exceptions bildet in Java den Mechanismus, um Fehler und Abstürze im Programmablauf sicher zu behandeln. In eigenen Programmen kann es sinnvoll sein, die vordefinierten Exceptions zu erweitern oder eigene zu deklarieren.

Das Exception-Handling, die Fehlerbehandlung, findet durch spezielle Klassen statt, die allesamt letztlich von der Klasse Throwable abgeleitet sind. Anstatt nun einfach diese zu erweitern ist es ratsamer, die eigenen Exceptions von der Klasse Exception abzuleiten, die von Throwable erbt. Selbstverständlich kann auch eine weiter spezialisierte Klasse als Elternklasse für die eigenen Exceptions herhalten.
Im Beispiel wird eine eigene Klasse IntValueException deklariert, die zur Fehlerbehandlung verwendet werden soll, wenn bei Multiplikationen Integer-Werte die zulässigen Grenzen unter- oder überschreiten. In diesem Fall ist sie direkt von der Klasse Exception abgeleitet und überschreibt zwei von deren Konstruktoren.

public class ExceptionTest {

    public static boolean checkIntValueForMultiplication(int i, int j) {
        // einer von beiden Multiplikanten negativ -> Ergebnis negativ
        if ((i < 0 || j < 0) && !(i < 0 && j < 0)) {
            if ((j < 0 && j < Integer.MIN_VALUE / Math.abs((double) i))
                    || (i < 0 && i < Integer.MIN_VALUE / Math.abs((double) j))) {
                try {
                    throw new IntValueException(
                            "Minimaler Integer-Wert unterschritten!");
                } catch (IntValueException e) {
                    System.err.println(e.getMessage());
                }
                return false;
            }
        }
        // beide Multiplikanten negativ -> Ergebnis positiv
        if (i < 0 && j < 0) {
            if (j < Integer.MIN_VALUE / -i || i < Integer.MIN_VALUE / -j) {
                try {
                    throw new IntValueException(
                            "Maximaler Integer-Wert \u00FCberschritten!");
                } catch (IntValueException e) {
                    System.err.println(e.getMessage());
                }
                return false;
            }
        }
        // beide Multiplikanten positiv -> Ergebnis positiv
        if (i > 0 && j > 0) {
            if (j > Integer.MAX_VALUE / i || i > Integer.MAX_VALUE / j) {
                try {
                    throw new IntValueException(
                            "Maximaler Integer-Wert \u00FCberschritten!");
                } catch (IntValueException e) {
                    System.err.println(e.getMessage());
                }
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int i = -70000, j = 70000;
        if (checkIntValueForMultiplication(i, j))
            System.out.println(i * j);
    }
}

class IntValueException extends Exception {
    String s;

    public IntValueException() {
        this(null);
    }

    public IntValueException(String s) {
        super(s);
        this.s = s;
    }
}

In der Methode checkIntValueForMultiplication() werden die Multiplikanden auf ihre Ober- und Untergrenzen hin überprüft. Hierbei werden je nach Vorzeichenbelegung drei Fälle unterschieden:

Da Java das Über- bzw. Unterschreiten der erlaubten Integer-Grenzen nicht anzeigt, kann das Ergebnis einer die Grenzen überschreitenden Multiplikation nicht stimmig ausgegeben werden. Der Test findet aus diesem Grunde über eine Division statt, bei der die erlaubte Größe eines Multiplikanden gegen diejenige des zweiten geprüft wird.
Bei Über- oder Unterschreiten wird innerhalb eines try-catch-Blocks versucht, die selbst implementierte IntValueException zu werfen.