Umgang mit Mehreren Exceptions

Wie im vorherigen Kapitel erwähnt, können wir mehrere Ausnahmen haben, und für jede dieser Ausnahmen können wir einen separaten Catch-Block haben.

Mehrere `catch` Blöcke

Schauen wir uns ein Codebeispiel an, das einen String in einen int parst und dann eine Division durchführt. In diesem Fall können zwei Ausnahmen auftreten:

ArithmeticException, wenn wir versuchen, durch null zu teilen;
NumberFormatException, wenn es unmöglich ist, den String in einen int zu konvertieren.

Die Methode ist sehr einfach, wirft aber genügend Ausnahmen.

Verwenden wir diese Methode in der Hauptklasse und behandeln beide Ausnahmen mit einer try-catch-Struktur:

main


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10";
            int divisor = 0;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException caught");
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException caught");
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Wie Sie sehen können, behandeln wir mehrere Ausnahmen, eine nach der anderen, indem wir zwei catch-Blöcke verwenden. Wenn wir die erste Ausnahme abfangen, in unserem Fall ArithmeticException, betreten wir den ersten Catch-Block und zeigen die notwendigen Informationen auf dem Bildschirm an.

Wenn wir den zweiten Fehler abfangen, der in diesem Fall NumberFormatException ist, betreten wir den nächsten Catch-Block, wo wir die erforderlichen Informationen auf dem Bildschirm anzeigen.

Wir geben jedem der Fehler auch ein Alias, 'e', das es uns ermöglicht, auf das Objekt zuzugreifen und zu verstehen, was schiefgelaufen ist.

Dies geschieht mit e.getMessage(). Im Code sieht es so aus:

main


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10";
            int divisor = 0;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException caught: " + e.getMessage());
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException caught: " + e.getMessage());
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Kombinieren mehrerer `catch`-Blöcke

Sie werden feststellen, dass wir in beiden catch-Blöcken die gleiche Operation ausführen, was darauf hindeutet, dass wir sie kombinieren könnten. Java erlaubt uns, dies durch das Abfangen beider Ausnahmeobjekte in einem einzigen catch-Block zu tun.

Zum Beispiel:

main


              123456789101112131415161718192021222324
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10d";
            int divisor = 2;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (ArithmeticException | NumberFormatException e) {
            System.out.println(e.getClass().getSimpleName() + " caught: " + e.getMessage());
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Wir haben mehrere mögliche Ausnahmen aufgelistet, die wir mit dem bitweisen ODER (|) abfangen können. Auf diese Weise fangen wir in einem catch-Block zwei mögliche Ausnahmen gleichzeitig ab und zeigen eine gemeinsame Nachricht für sie an.

Wir können diesen catch-Block leicht verkürzen, indem wir das übergeordnete Ausnahme-Klassenobjekt verwenden: RuntimeException.

Lassen Sie uns dies im folgenden Code implementieren:

main


              123456789101112131415161718192021222324
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10";
            int divisor = 0;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (RuntimeException e) {
            System.out.println(e.getClass().getSimpleName() + " caught: " + e.getMessage());
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Wir können daraus schließen, dass Ausnahmen auch ihre eigene Vererbungshierarchie haben und wir eine Kindklasse durch eine Elternklasse ersetzen können, sowie Abhängigkeitsinversion verwenden können.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 3

Java JUnit Bibliothek. Arten von Tests

Umgang mit Mehreren Exceptions

Mehrere `catch` Blöcke

Kombinieren mehrerer `catch`-Blöcke

1. Welche Ausnahmen kann die Methode `divideAndConvert` potenziell auslösen?

2. Im bereitgestellten Beispiel, was verursacht eine `NumberFormatException`?

3. Was ist der Zweck der Kombination mehrerer Catch-Blöcke?

4. Wie können Sie mehrere Ausnahmen in einem einzigen Catch-Block abfangen?

5. Wenn Sie `RuntimeException` abfangen, welche Arten von Ausnahmen behandeln Sie?

Java JUnit Bibliothek. Arten von Tests

Umgang mit Mehreren Exceptions

Mehrere `catch` Blöcke

Kombinieren mehrerer `catch`-Blöcke

1. Welche Ausnahmen kann die Methode divideAndConvert potenziell auslösen?

2. Im bereitgestellten Beispiel, was verursacht eine NumberFormatException?

3. Was ist der Zweck der Kombination mehrerer Catch-Blöcke?

4. Wie können Sie mehrere Ausnahmen in einem einzigen Catch-Block abfangen?

5. Wenn Sie RuntimeException abfangen, welche Arten von Ausnahmen behandeln Sie?

1. Welche Ausnahmen kann die Methode `divideAndConvert` potenziell auslösen?

2. Im bereitgestellten Beispiel, was verursacht eine `NumberFormatException`?

5. Wenn Sie `RuntimeException` abfangen, welche Arten von Ausnahmen behandeln Sie?