10.31 10.27课后作业

掌握 try-catch-finally 语法结构的执行逻辑，理解异常发生时程序的控制流跳转。
无异常场景：try 块代码正常执行，跳过 catch 块，直接执行 finally 块。
示例代码片段：
try {
int a = 10 / 2; // 无异常
System.out.println("计算结果：" + a); // 会执行
} catch (ArithmeticException e) {
System.out.println("除数不能为0"); // 不会执行
} finally {
System.out.println("无论是否有异常，我都会执行"); // 会执行
}
运行结果：
plaintext
计算结果：5
无论是否有异常，我都会执行
有异常场景：try 块中发生异常，立即跳转至匹配的 catch 块处理，最后执行 finally 块。
示例代码片段：
try {
int a = 10 / 0; // 发生 ArithmeticException
System.out.println("计算结果：" + a); // 不会执行（异常后代码中断）
} catch (ArithmeticException e) {
System.out.println("捕获异常：" + e.getMessage()); // 会执行
} finally {
System.out.println("无论是否有异常，我都会执行"); // 会执行
}
运行结果：
plaintext
捕获异常：/ by zero
无论是否有异常，我都会执行
结论
finally 块是 “善后” 代码（如关闭文件、释放资源）的核心位置，无论 try 块是否发生异常，都会强制执行。
2.
CatchWho.java 代码分析与运行结果
代码逻辑拆解
java
运行
public class CatchWho {
public static void main(String[] args) {
try { // 外层 try
try { // 内层 try
throw new ArrayIndexOutOfBoundsException(); // 抛出数组越界异常
} catch (ArrayIndexOutOfBoundsException e) { // 内层 catch 匹配数组越界异常
System.out.println("ArrayIndexOutOfBoundsException/内层try-catch");
}
throw new ArithmeticException(); // 内层 try-catch 处理完后，外层抛出算术异常
} catch (ArithmeticException e) { // 外层 catch 匹配算术异常
System.out.println("发生ArithmeticException");
} catch (ArrayIndexOutOfBoundsException e) { // 外层 catch 不匹配（内层已处理）
System.out.println("ArrayIndexOutOfBoundsException/外层try-catch");
}
}
}
运行结果
plaintext
ArrayIndexOutOfBoundsException/内层try-catch
发生ArithmeticException
关键原因
内层 try 抛出的 ArrayIndexOutOfBoundsException 被内层 catch 精准捕获，不会向外传播。
内层处理完成后，程序继续执行外层 try 中剩余代码（throw new ArithmeticException()），该异常被外层 catch (ArithmeticException e) 捕获。
3.
验证多层嵌套 try-catch-finally 中，finally 的执行顺序（遵循 “先内层、后外层” 的栈式顺序）。
public class EmbedFinally {
public static void main(String[] args) {
try { // 外层 try
System.out.println("进入外层 try");
try { // 内层 try
System.out.println("进入内层 try");
int a = 10 / 0; // 抛出算术异常
} catch (ArithmeticException e) {
System.out.println("内层 catch：捕获算术异常");
} finally { // 内层 finally
System.out.println("内层 finally：执行");
}
} catch (Exception e) {
System.out.println("外层 catch：捕获异常"); // 内层已处理异常，此代码不执行
} finally { // 外层 finally
System.out.println("外层 finally：执行");
}
}
}
运行结果
plaintext
进入外层 try
进入内层 try
内层 catch：捕获算术异常
内层 finally：执行
外层 finally：执行
结论
嵌套 finally 的执行顺序与 try 的嵌套顺序相反：先执行内层 finally，再执行外层 finally。
即使内层 catch 处理了异常，内层 finally 依然会执行，且不会影响外层 finally 的执行。
4.
掌握 printStackTrace() 和 getMessage() 方法的用法，定位异常发生的位置和原因。
示例代码
java
运行
public class PrintExpressionStack {
// 模拟多层方法调用
public static void methodA() {
methodB(); // 调用 methodB
}

public static void methodB() {
    methodC(); // 调用 methodC
}

public static void methodC() {
    int a = 10 / 0; // 发生异常
}

public static void main(String[] args) {
    try {
        methodA();
    } catch (ArithmeticException e) {
        // 1. getMessage()：获取异常的简要描述
        System.out.println("异常信息（getMessage）：" + e.getMessage());
        // 2. printStackTrace()：打印异常的完整传播路径（方法调用栈）
        System.out.println("\n异常传播路径（printStackTrace）：");
        e.printStackTrace();
    }
}

}
运行结果
plaintext
异常信息（getMessage）：/ by zero

异常传播路径（printStackTrace）：
java.lang.ArithmeticException: / by zero
at PrintExpressionStack.methodC(PrintExpressionStack.java:14)
at PrintExpressionStack.methodB(PrintExpressionStack.java:10)
at PrintExpressionStack.methodA(PrintExpressionStack.java:6)
at PrintExpressionStack.main(PrintExpressionStack.java:18)
关键结论
getMessage()：仅返回异常的核心原因（如 / by zero），适合快速了解异常类型。
printStackTrace()：返回异常的完整调用栈，包括异常类型、原因、发生的类、方法、行号，是定位异常位置的核心工具（开发阶段必备）。