Exception Handling in Java: Unraveling the Ambiguity

In a puzzling Java exception-handling scenario, a university question presented the following code snippet:

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

// Main Class
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 its output, and the answer provided was "13Exception in thread main MyExc2". However, the correct answer is "132Exception in thread main MyExc1".

Clarifying the Ambiguity

To decipher this puzzle, it's essential to understand the precedence of exceptions:

• Principle: When a new exception is thrown within a catch or finally block, the current exception being handled is aborted.

• Consequences:

  • The current exception's propagation is halted.
  • The new exception becomes the propagating exception.
  • The new exception unwinds up the stack as normal, encountering any applicable catch or finally blocks.

Retracing the Execution

Applying this principle to the code:

1. Initial Execution:

   • Line 13: MyExc1 is thrown in the try block of q().
   • Line 18: The MyExc1 is caught in the catch block of q().
   • Line 21: Line 21 is executed (prints 3).

2. Catch Block Exception:

   • Line 19: MyExc2 is thrown in the catch block of main().
   • Line 22: MyExc2 aborts the propagation of MyExc1.
   • Line 19: MyExc2 starts unwinding up the stack.

3. Execution Resumes in Main's Try Block:

   • Line 15: Line 15 is executed (prints 2).
   • Line 16: MyExc1 is thrown in the finally block of main().
   • Line 16: MyExc1 aborts the propagation of MyExc2.
   • Line 16: MyExc1 starts unwinding up the stack (and is still subject to main's finally block).

4. Finally Block Exception:

   • Line 23: Exception is thrown in the finally block of main().
   • Line 23: Exception aborts the propagation of MyExc1.
   • Line 23: Exception starts unwinding up the stack.

Output:

The final output is "132Exception in thread main MyExc1" because the exception that propagates out of the main method is the MyExc1 thrown in line 16. The MyExc2 thrown in line 19 is aborted when MyExc1 is thrown in line 16.