Exception Handling in Catch and Finally Clauses

When dealing with exception handling in Java, it's crucial to grasp the interplay between catch and finally clauses. Consider the following example provided for a university assignment:

class MyExc1 extends Exception {}
class MyExc2 extends Exception {}
class MyExc3 extends MyExc2 {}

public class C1 {
    public static void main(String[] args) throws Exception {
        try {
            System.out.print(1);
            q();
        }
        catch (Exception i) {
            throw new MyExc2();
        }
        finally {
            System.out.print(2);
            throw new MyExc1();
        }
    }

    static void q() throws Exception {
        try {
            throw new MyExc1();
        }
        catch (Exception y) {
        }
        finally {
            System.out.print(3);
            throw new Exception();
        }
    }
}

The question asked for the output of this code. While some may have answered "13Exception in thread main MyExc2," the correct answer is "132Exception in thread main MyExc1."

Why MyExc2 Disappears

The key to understanding the correct output lies in the behavior of catch and finally clauses. When an exception is thrown within a catch or finally block, it has significant implications on the flow. Here's a breakdown:

• Exception in catch block: If a new exception is thrown in a catch block (as seen with throw new MyExc2() above), the original exception is "aborted." The current execution path is left incomplete, and the new exception takes over as the one that propagates outward.

• Exception in finally block: Similarly, if a new exception is thrown in a finally block, the original exception is also aborted. However, there's a crucial point to note:

  • Catch block's finally block: If the new exception is thrown in a catch block's finally block, it will still be subject to that catch's finally block, if any.

Tracing the Exceptions

Tracing the execution based on these principles, we can see that:

1. The try block in main prints "1" and calls q().
2. Inside q(), the try block throws a MyExc1.
3. The catch block in q() handles the exception silently.
4. The finally block in q() prints "3" and throws an Exception.

5. Catch block in main:

   • The MyExc2 is thrown in this block, aborting the original MyExc1.
   • However, the catch block has a finally block that still executes.

6. Finally block in main:

   • The MyExc1 is thrown in this block, aborting the MyExc2.

Therefore, the correct output is "132Exception in thread main MyExc1." The MyExc2 exception is "forgotten" because a new exception (MyExc1) is thrown in the finally block of the catch block that was handling the MyExc2.