All 15 Exceptions questions
More in Exceptions
What is the basic syntax and control flow of a try-catch-finally block, and what determines which catch block (if multiple exist) handles a thrown exception? What is the correct usage of try-with-resources, and how does it automatically ensure a resource's close() method is called even if an exception occurs? What is a common anti-pattern with catching exceptions too broadly (catch (Exception e) or worse, catch (Throwable t)), and why is it generally discouraged? What is the finally block's execution guarantee, and what are the specific edge cases where a finally block might NOT execute? What is the difference between Error and Exception in Java's Throwable hierarchy, and why should application code generally avoid catching Error subclasses like OutOfMemoryError or StackOverflowError? How do you create and throw a custom exception class, and what constructors should a well-designed custom exception typically provide? What is the purpose of the addSuppressed() mechanism and getSuppressed() method on Throwable, and in what specific scenario does the JVM automatically populate suppressed exceptions? How does exception chaining (via the cause mechanism, initCause() or a constructor accepting a Throwable) preserve the original root-cause exception when wrapping and rethrowing a different exception type, and why does this matter for debugging? How would you design a custom exception hierarchy for an application, deciding when to create new exception classes versus reusing existing ones, and what fields/context should a well-designed custom exception carry? How does exception handling interact with performance, particularly regarding the cost of filling in a stack trace, and how would you optimize exception usage in a performance-critical hot path?
Advertisement
Back to results for “Java Fundamentals: Syntax”
Java › Exceptions

What is the multi-catch syntax (catch (IOException | SQLException e)) introduced in Java 7, and what restriction applies to the exception types combined in a single multi-catch block?

Intermediate

Answer

Multi-catch lets a single catch block handle multiple, unrelated exception types with identical handling logic, avoiding duplicated catch blocks with the exact same body for each type -- the restriction is that the combined exception types must not be related by a subclass/superclass relationship (catching both a specific exception AND its own supertype together in the same multi-catch is redundant and rejected by the compiler), and the resulting caught variable is implicitly treated as the most specific common supertype of the listed types (and effectively final, so it can't be reassigned within the catch block).
try {
    riskyIOOperation();
    riskyDatabaseOperation();
} catch (IOException | SQLException e) {
    // shared handling logic for both, avoiding duplicated catch blocks
    log.error("Operation failed", e);
    throw new ServiceException("Operation failed", e);
}
// e's static type here is Exception (the nearest common supertype of IOException and SQLException)
Real-world example A method that can fail with either an IOException or a SQLException, but wants identical error-logging-and-wrapping behavior for both, uses multi-catch to consolidate what would otherwise be two nearly-identical catch blocks into one, reducing code duplication while still only catching the specific types actually expected.

Common follow-ups: Why does the compiler reject combining a supertype and its own subtype together in a multi-catch?;How does the caught variable's static type get determined when the combined exception types don't share an obvious common ancestor beyond Exception?

Error Handling;Java Fundamentals: Syntax Data Types & Operators
All 15 Exceptions questions