Is it possible in Java to catch two exceptions in the same catch block?

exception, java, try-catch

Solution

Java 7 and later

Multiple-exception catches are supported, starting in Java 7.

The syntax is:

try {
     // stuff
} catch (Exception1 | Exception2 ex) {
     // Handle both exceptions
}

The static type of `ex` is the most specialized common supertype of the exceptions listed. There is a nice feature where if you rethrow `ex` in the catch, the compiler knows that only one of the listed exceptions can be thrown.

Java 6 and earlier

Prior to Java 7, there are ways to handle this, but they are inelegant and have limitations.

Approach #1

try {
     // stuff
} catch (Exception1 ex) {
     handleException(ex);
} catch (Exception2 ex) {
     handleException(ex);
}

public void handleException(SuperException ex) {
     // handle exception here
}

This gets messy if the exception handler needs to access local variables declared before the `try`. And if the handler method needs to rethrow the exception (and it is checked) then you run into serious problems with the signature. Specifically, `handleException` has to be declared as throwing `SuperException` ... which potentially means you have to change the signature of the enclosing method, and so on.

Approach #2

try {
     // stuff
} catch (SuperException ex) {
     if (ex instanceof Exception1 || ex instanceof Exception2) {
         // handle exception
     } else {
         throw ex;
     }
}

Once again, we have a potential problem with signatures.

Approach #3

try {
     // stuff
} catch (SuperException ex) {
     if (ex instanceof Exception1 || ex instanceof Exception2) {
         // handle exception
     }
}

If you leave out the `else` part (e.g. because there are no other subtypes of `SuperException` at the moment) the code becomes more fragile. If the exception hierarchy is reorganized, this handler without an `else` may end up silently eating exceptions.

Note: if `SuperException` in the above is `Exception` you will either eat (all) unchecked exceptions or find that you are rethrowing an exception with the signature `Exception`. Both of those things will be problematic.

Problem

I need to catch two exceptions because they require the same handling logic. I would like to do something like: ``` catch (Exception e, ExtendsRuntimeException re) { // common logic to handle both exceptions } ``` Is it possible to avoid duplicating the handler code in each catch block?

Original source

Related problems