Java Catch Multiple Exceptions, Rethrow Exception – Leitfaden

In Java 7 wurde der catch-Block verbessert, um mehrere Ausnahmen in einem einzigen catch-Block zu behandeln. Wenn Sie mehrere Ausnahmen fangen und diese ähnlichen Code haben, dann wird durch die Verwendung dieser Funktion die Code-Duplizierung reduziert. Lassen Sie uns das Feature zum Fangen mehrerer Ausnahmen in Java anhand eines Beispiels verstehen.

Java Catch Multiple Exceptions

Vor Java 7 haben wir mehrere Ausnahmen nacheinander gefangen, wie unten gezeigt.

catch (IOException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
catch (SQLException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

In Java 7 können wir beide dieser Ausnahmen in einem einzigen catch-Block fangen, wie folgt:

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Wenn ein catch-Block mehrere Ausnahmen behandelt, können Sie diese mit einem senkrechten Strich (|) trennen, und in diesem Fall ist der Ausnahmeparameter (ex) final, sodass Sie ihn nicht ändern können. Der von dieser Funktion generierte Bytecode ist kleiner und reduziert die Redundanz im Code.

Java Rethrow Exception

Ein weiterer Fortschritt wurde in der Compiler-Analyse von erneut geworfenen Ausnahmen gemacht. Die Funktion zum erneuten Werfen von Ausnahmen in Java ermöglicht es Ihnen, spezifischere Ausnahmetypen in der throws-Klausel einer Methodendeklaration anzugeben. Lassen Sie uns dies anhand eines kleinen Beispiels sehen:

package com.journaldev.util;

public class Java7MultipleExceptions {

    public static void main(String[] args) {
        try{
            rethrow("abc");
        }catch(FirstException | SecondException | ThirdException e){
            System.out.println(e.getMessage());
        }
    }

    static void rethrow(String s) throws FirstException, SecondException,
            ThirdException {
        try {
            if (s.equals("First"))
                throw new FirstException("First");
            else if (s.equals("Second"))
                throw new SecondException("Second");
            else
                throw new ThirdException("Third");
        } catch (Exception e) {
            throw e;
        }
    }

    static class FirstException extends Exception {
        public FirstException(String msg) {
            super(msg);
        }
    }

    static class SecondException extends Exception {
        public SecondException(String msg) {
            super(msg);
        }
    }

    static class ThirdException extends Exception {
        public ThirdException(String msg) {
            super(msg);
        }
    }

}

Wie Sie im rethrow-Verfahren sehen können, fängt der catch-Block eine Ausnahme, aber sie ist kein Teil der throws-Klausel. Der Java 7-Compiler analysiert den kompletten try-Block, um zu prüfen, welche Arten von Ausnahmen geworfen und dann aus dem catch-Block erneut geworfen werden. Beachten Sie, dass diese Analyse deaktiviert wird, wenn Sie das Argument des catch-Blocks ändern.