Detailed explanation
Multi-catch, introduced in Java 7, lets one catch block handle several exception types when their recovery, logging, or propagation logic is identical. You separate the types with the pipe (|) symbol: catch (IOException | SQLException e) { System.out.println("Error: " + e.getMessage()); }. Here, either matching exception enters the same handler. The symbol separates alternative types; it is not a boolean OR expression. This feature reduces duplicated code while keeping the exceptions you intend to handle explicit.
When an exception leaves the try block, Java looks for the first compatible catch clause in declaration order. A multi-catch clause matches if the thrown object is an instance of any listed type, including its subclasses. It does not combine exceptions or handle several thrown objects simultaneously: each execution handles one exception object through the parameter e. In compiled bytecode, multiple exception-table entries can direct matching exceptions to the same handler code. Checked-exception rules still apply, so listing a checked type such as IOException generally requires the try block to contain an operation that can throw it.
The alternatives must not have a subtype relationship with one another. For example, catch (IOException | FileNotFoundException e) is illegal because FileNotFoundException already extends IOException; catching IOException alone covers both. The parameter in a multi-catch block is implicitly final, so you cannot assign another exception to e. Its usable members come from the common type information of the alternatives. For IOException and SQLException, you can call shared Exception methods such as getMessage(), but not SQLException-specific methods such as getSQLState() directly.
In interviews, explain that multi-catch is appropriate only when the handling behaviour is genuinely shared. Separate catch blocks remain clearer when different exceptions require different recovery actions. Compared with catch (Exception e), multi-catch expresses a narrower handling policy and avoids unintentionally catching unrelated exceptions. Interviewers commonly check the syntax, the subtype restriction, and the implicitly final parameter—not just whether you know that it saves lines of code.
Key points to remember
- Java 7+ supports multiple exception alternatives in one catch clause using |.
- Use multi-catch when all listed exceptions need identical handling.
- Alternatives cannot be subtypes of one another.
- The multi-catch parameter is implicitly final and cannot be reassigned.
- Matching subclasses are also caught; each handler invocation receives one exception object.
Common mistakes candidates make
- Combining a superclass and its subclass, such as Exception | IOException.
- Reassigning the exception parameter inside a multi-catch block.
- Grouping exceptions that require different recovery actions merely to reduce code.
Likely follow-up questions
How is multi-catch different from catching Exception?
Multi-catch handles only the listed exception types and their subclasses. Catching Exception also catches other checked exceptions and runtime exceptions that reach that handler, potentially masking failures you did not intend to handle.
Can multi-catch combine checked and unchecked exceptions?
Yes, for example catch (IOException | IllegalArgumentException e), provided the alternatives have no subtype relationship. The checked alternative must still satisfy Java's compile-time exception-checking rules.
Can you rethrow the exception from a multi-catch block?
Yes, you can write throw e; because rethrowing does not reassign the parameter. If IOException and SQLException can escape the method, its throws clause must cover those checked types, unless an enclosing handler catches them.
Interview tip: Start with the syntax and shared-handling purpose, then mention the subtype restriction and implicitly final parameter using one short example.