In Java exception handling, how does a try statement decide which catch block will handle a thrown exception?

Introduction / Context:
Java exception handling uses try, catch, and finally blocks to manage error conditions. Understanding how the JVM chooses which catch block to execute is crucial for writing correct and predictable exception handling code. Interviewers ask this to verify that you understand exception hierarchy, catch order, and how specific and general exceptions interact.

Given Data / Assumptions:

• A try block may be followed by multiple catch blocks.
• An exception is thrown somewhere inside the try block.
• The catch blocks declare different exception types, sometimes in an inheritance relationship.
• The order of the catch blocks in the source code is significant.

Concept / Approach:
When an exception is thrown inside a try block, the JVM looks for an appropriate catch block. It checks each catch block from top to bottom in the order they appear. The first catch clause whose parameter type is the same as, or a superclass of, the thrown exception type is chosen to handle the exception. This means you must place more specific exception types before more general ones, otherwise the general catch will capture the exception and the specific one will become unreachable, causing a compile time error.

Step-by-Step Solution:
1. A try block contains code that might throw exceptions, for example file operations or parsing. 2. Multiple catch blocks follow, such as catch (FileNotFoundException e), catch (IOException e), and catch (Exception e). 3. If a FileNotFoundException is thrown, the JVM first checks the first catch block. 4. If the first catch block parameter type matches the thrown exception type or is a superclass of it, that block executes and handles the exception. 5. Once a matching catch block is found and executed, no subsequent catch blocks are considered for that exception, and control moves beyond the catch sequence.

Verification / Alternative check:
You can test this understanding by writing a try block that deliberately throws a subclass exception and placing a generic Exception catch before the subclass catch. The compiler will flag the subclass catch as unreachable because the Exception catch will match everything first. Reordering the catch blocks to place the subclass first solves the problem. This shows that the first compatible catch in top to bottom order is the one that executes.

Why Other Options Are Wrong:
Option B is wrong because the last catch block does not automatically handle all exceptions; ordering is top to bottom. Option C is incorrect because the JVM does not randomly select a catch; it follows clear deterministic rules. Option D is wrong because a catch for Throwable is very general and should appear last; if it appears earlier, more specific catches later become unreachable. Java encourages catching more specific exceptions first and only catching Throwable or Exception when necessary.

Common Pitfalls:
Developers sometimes place a general catch (such as catch (Exception e)) before more specific catches, which makes the specific ones unreachable and leads to compilation errors. Another pitfall is catching overly broad exceptions and then silently ignoring them, which hides real problems. A good practice is to order catch blocks from most specific to most general and to handle each exception in a way that makes sense for the context.

Final Answer:
The first catch block whose exception type matches the thrown exception type or its superclass, in top to bottom order, handles the exception.