Java中的异常处理：解开歧义

在一个令人费解的Java异常处理场景中，一个大学问题提出了以下代码片段：

// 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();
        }
    }
}

该问题询问其输出，提供的答案是“13Exception in thread main MyExc2”。然而，正确的答案是“132Exception in thread main MyExc1”。

澄清歧义

要破译这个谜题，必须了解异常的优先级：

• 原理：当catch或finally块中抛出新的异常时，当前正在处理的异常将被中止。

• 后果:

  • 当前异常的传播停止。
  • 新异常成为传播异常。
  • 新异常正常展开堆栈，遇到任何适用的 catch 或 finally 块。

追溯执行

将此原则应用于代码：

1. 初始执行:

   • 第 13 行: MyExc1 被抛出到 q() 的 try 块中。
   • 第 18 行: MyExc1 被 q() 的 catch 块捕获。
   • 第 21 行：执行第 21 行（打印 3）。

2. Catch 块异常：

   • 第 19 行：MyExc2 被抛出到 main() 的 catch 块中。
   • 第 22 行：MyExc2 中止 MyExc1 的传播。
   • 第 19 行：MyExc2 开始展开堆栈。

3. Main 的 Try 块中恢复执行：

   • 第 15 行：第 15 行被执行（打印 2）。
   • 第 16 行：MyExc1 被抛出到 main() 的finally 块中。
   • 第 16 行：MyExc1 中止 MyExc2 的传播。
   • 第16行：MyExc1开始展开堆栈（并且仍然受main的finally块的影响）。

4. Finally Block异常：

   • 第 23 行：在 main() 的 finally 块中抛出异常。
   • 第 23 行：异常中止 MyExc1 的传播。
   • 第 23 行：异常开始展开

输出：

最终输出是“132Exception in thread main MyExc1”，因为传播出去的异常main 方法的主方法是第 16 行抛出的 MyExc1。第 19 行抛出的 MyExc2 在第 16 行抛出 MyExc1 时中止。