Analyzing Java try‑finally and try‑catch‑finally Execution Through Bytecode

While studying the Java Virtual Machine specification, the author found that directly analyzing bytecode deepens understanding of Java language semantics, especially for exception handling constructs.

First, a simple try‑finally example without a catch block is presented:

public class ExceptionTest {
  public void tryFinally() {
    try {
      tryItOut();
    } finally {
      wrapItUp();
    }
  }
  public void tryItOut() {}
  public void wrapItUp() {}
}

Running javap -c ExceptionTest reveals the bytecode. When no exception is thrown, the execution sequence is:

0: aload_0
1: invokevirtual #2 // Method tryItOut:()V
4: aload_0
5: invokevirtual #3 // Method wrapItUp:()V
18: return

If an exception occurs, the JVM uses the exception table to jump to the handler at byte offset 11, where the exception object is stored in a local variable before the finally block is executed and the exception is re‑thrown:

11: astore_1
12: aload_0
13: invokevirtual #3 // Method wrapItUp:()V
16: aload_1
17: athrow

The key conclusion is that in a try‑finally construct, any exception thrown in the try block is first saved, the finally block runs, and then the exception is re‑thrown.

The article then modifies the example to include a return statement inside the try block:

public void tryFinally() {
  try {
    tryItOut();
    return;
  } finally {
    wrapItUp();
  }
}

Disassembling shows that the finally code is still placed before the return instruction, confirming that the finally block always executes before the method returns.

Finally, a try‑catch‑finally example is added:

public void tryCatchFinally() {
  try {
    tryItOut();
  } catch (TestExc e) {
    handleExc(e);
  } finally {
    wrapItUp();
  }
}

The generated bytecode and exception table demonstrate that the catch block is also covered by the finally region, and that a return inside a catch still executes the finally code first.

Overall, the bytecode analysis clarifies the precise order of operations for Java's exception handling constructs.