All 15 Exceptions questions
More in Exceptions
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 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? 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? 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? How would you implement a custom checked exception that requires additional context to be attached as the exception propagates up multiple layers of a call stack, without losing information at each layer? How does exception handling interact with generics and type erasure, specifically regarding why you cannot catch a generic type parameter as an exception type (catch (T e))? How would you design and implement a global, centralized exception-handling strategy for a Java application (such as a top-level handler in main(), or an uncaught exception handler for background threads), ensuring no exception silently crashes the application without being logged?
Advertisement
Java › Exceptions

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?

Intermediate

Answer

Suppressed exceptions handle the scenario where a try-with-resources block's body throws an exception, AND the automatic close() call on one or more resources ALSO throws an exception during cleanup -- rather than losing one of these two genuinely important pieces of information, the JVM propagates the original (primary) exception from the try block's body while automatically attaching the close()-triggered exception(s) as suppressed exceptions on it, accessible via getSuppressed(), ensuring neither failure is silently discarded even though only one exception can be the 'main' one propagating up the call stack.
try (AutoCloseable resource = () -> { throw new IOException("close failed"); }) {
    throw new RuntimeException("operation failed");  // this becomes the PRIMARY exception
}
// Catching this: e.getMessage() == "operation failed"
// e.getSuppressed()[0].getMessage() == "close failed" -- NOT lost, just attached as suppressed
Real-world example A database transaction wrapped in try-with-resources throws a business-logic exception while its connection's close() method also fails due to a broken network connection, and the resulting stack trace shows both failures clearly (the primary business exception plus the suppressed connection-close failure), giving a complete diagnostic picture instead of silently losing one of the two failures.

Common follow-ups: How would you programmatically inspect and log all suppressed exceptions attached to a caught exception?;What's the difference conceptually between a suppressed exception and a chained cause exception?

I/O & NIO;Logging in Java (java.util.logging SLF4J Log4j)
All 15 Exceptions questions