5.3 异常处理及语法

思维导图：

 

5.3 异常处理及语法

5.3.1 异常的产生及处理

关键概念:

• 异常的影响: 异常发生时，会打断程序的正常流程，输出错误信息，并中止程序。
• 处理目的: 正确处理异常可以避免程序中断，保证程序的鲁棒性。

流程跳转:

• 捕获异常 → 程序流程跳转 → 异常处理代码块。
• 未处理异常 → 程序跳出 → 返回操作系统。

Java异常处理关键字:

1. try - 放置可能引发异常的代码。
2. catch - 捕获并处理特定类型的异常。
3. finally - 无论是否捕获到异常，finally块中的代码都会执行，用于资源释放等清理操作。
4. throw - 主动抛出异常对象。
5. throws - 在方法声明中使用，表示该方法可能抛出的异常，需要调用者处理。

关键字用途:

• try: 必须与至少一个catch或finally块配合使用。
• catch: 指定处理某一类型异常的代码块。
• finally: 常用于关闭或释放资源，如文件、数据库连接。
• throw: 手动抛出一个异常实例。
• throws: 用于方法签名，提醒方法的调用者需要对这些可能的异常进行处理。

异常处理流程:

1. 将可能引发异常的代码置于try块中。
2. 使用catch捕获并处理特定异常。
3. 无论是否发生异常，finally块中的代码总是执行。
4. 如果需要抛出异常，使用throw。
5. 如果方法不直接处理异常，而是希望调用者处理，则使用throws声明。

我的理解：

这一节介绍了Java中的异常处理机制，其核心在于理解异常（Exception）是什么，以及如何在程序中对它们进行管理。以下是异常处理概念的简要解释：

1. 异常 (Exception):

   • 异常是程序运行时发生的不正常情况，这些情况会打断正常的程序流程。
   • 异常分为两大类：编译时异常（checked exceptions）和运行时异常（unchecked exceptions，也称为运行时错误）。

2. 异常处理 (Exception Handling):

   • 异常处理是编程语言中的一种结构，用于处理程序运行时发生的特定错误，并允许程序安全地终止或继续执行。

3. try-catch-finally:

   • try块用于包围可能发生异常的代码。
   • catch块跟随try，用于捕获try块中发生的特定类型的异常，并定义处理这些异常的方式。
   • finally块无论是否捕获或处理异常，都会执行，通常用于清理资源（如关闭文件）。

4. throw 和 throws:

   • throw关键字用于手动抛出一个异常实例。
   • throws关键字用于在方法签名中声明该方法可能会抛出的异常类型，这意味着调用该方法的代码需要处理这些异常，或者再次声明抛出。

理解这一节的概念，就是要理解程序如何通过这些机制来应对运行时无法预料的情况，以避免程序崩溃并提供错误恢复的途径。异常处理的目的是提高程序的稳定性和安全性，允许开发者控制异常发生时的程序行为。

 

5.3.2 try...catch语句

概念：

• try 代码块：包围可能发生异常的代码段。
• catch 代码块：捕获try中抛出的异常，并定义如何处理它们。
• 异常传递：try块中发生的异常会被封装为异常对象，传递给catch块。

格式：

try {
    // 可能产生异常的代码
} catch (ExceptionType e) {
    // 异常处理代码
}

关键点：

1. try 代码块是强制性的。
2. 可以有多个 catch 代码块，对不同类型的异常做不同的处理。
3. 捕获父类异常的 catch 必须放在捕获子类异常的后面。
4. catch 必须紧跟在 try 后面。

异常处理流程（以图5-3为例）：

• 无异常：try 代码块执行完毕后，跳过 catch 直接执行后续代码。
• 有异常：try 中发生异常，立即跳转到对应 catch 代码块。
  • 匹配异常：执行 catch 代码块中的处理代码，之后继续执行后续代码。
  • 不匹配异常：如果没有合适的 catch 块匹配，程序会中断执行。

示例：

public class Example02 {
    public static void main(String[] args) {
        try {
            int result = divide(4, 0); // 尝试除以零
            System.out.println(result);
        } catch(Exception e) {
            System.out.println("捕获的异常信息为：" + e.getMessage());
            // 执行异常处理代码
        }
        System.out.println("程序继续向下执行…");
    }

    public static int divide(int x, int y) {
        return x / y; // 这里可能产生除以零的异常
    }
}

• 注意：try 代码块中，一旦异常发生，异常后的代码将不会执行（如 Example02 中的打印语句）。

运行结果（图5-4）：

• 输出："捕获的异常信息为：/ by zero"
• 程序继续执行：显示后续的 "程序继续向下执行…"。

我的理解：

这一节的概念围绕Java中的异常处理和 try...catch 语句展开。下面我来逐一解释：

1. 异常（Exception）：

   • 在Java中，异常是在运行时发生的问题，它会打断正常的程序流程。
   • 异常对象包含了关于错误的信息，比如错误的类型和程序中的位置。

2. try 代码块：

   • 这是用来包裹可能会抛出异常的代码段。
   • 如果在 try 代码块中的代码抛出了异常，那么这个异常可以被 catch 代码块捕获。

3. catch 代码块：

   • 它紧随 try 代码块之后，用来捕获和处理异常。
   • catch 块会指定可以处理的异常类型，并定义如何处理这些异常。
   • 你可以有多个 catch 块来捕获和处理不同类型的异常。

4. 异常对象：

   • 当异常发生时，会创建一个异常对象。
   • 这个对象会被传递给 catch 块，其中包含了异常的类型和描述。

5. 异常处理流程：

   • 如果 try 代码块中的代码没有引发异常，则继续执行 try 块之后的代码。
   • 如果 try 代码块中的代码引发了异常，Java运行时系统会查找相应的 catch 块来处理它。
   • 如果找到了匹配的 catch 块，就执行该块内的代码来处理异常。
   • 如果没有找到匹配的 catch 块，异常会向上传播，可能导致程序终止。

6. catch 代码块的参数：

   • 这是一个异常类型的参数，指明了该 catch 块能处理什么类型的异常。

7. 处理后的流程：

   • 在异常被 catch 块捕获并处理后，程序会继续执行 catch 块之后的代码，而不是终止运行。

理解这一节的关键是要知道异常处理机制是如何允许程序在出错时能够优雅地恢复和继续执行，而不是直接崩溃退出。通过正确使用 try...catch 语句，可以让你的程序对用户和开发者都更加友好，因为它们可以提供有关什么出了问题以及如何解决问题的有用信息，并且允许程序有机会清理资源，或者至少有序地失败，而不是突然崩溃。

5.3.3 finally 语句

概念

• finally 代码块用于确保一段代码无论是否发生异常都会执行。
• 它是 try...catch 结构的一个可选部分，但不能单独使用。

结构

try {
    // 可能抛出异常的代码块
} catch (ExceptionType e) {
    // 异常处理代码块
} finally {
    // 无论是否发生异常，都会执行的代码块
}

特点

• finally 代码块必须位于所有 catch 代码块之后。
• finally 代码块总是会执行，除非：
  • 被执行的线程终止。
  • 使用了 System.exit(0) 退出程序。
  • 程序所在的线程死锁或无限循环。

流程

• 如果 try 代码块中没有异常发生，finally 代码块将在 try 代码块之后执行。
• 如果 try 代码块中有异常发生并被 catch 捕获，finally 代码块将在 catch 代码块之后执行。
• 如果 try 代码块中有异常发生但未被任何 catch 捕获，finally 代码块将在异常传播给上层调用者前执行。

作用

• 常用于清理资源，比如关闭文件、释放锁、断开网络连接等，无论成功还是异常结束。

示例修改

• 在文件5-3中，即使 catch 代码块中有 return 语句，finally 代码块中的代码依然会执行。
• finally 代码块提供了一种保证，确保某些必要的清理工作一定会发生。

注意点

• 即使 catch 代码块中有 return 语句，finally 代码块也会在方法返回给调用者之前执行。
• 使用 System.exit(0) 将导致JVM退出，此时 finally 代码块不会执行。

运行结果

• 示例程序中，即使发生异常，finally 代码块也确保了"进入finally代码块"的打印。

我的理解：

理解finally语句的概念，可以从它在异常处理中的三个主要作用来入手：

1. 确保代码执行： 无论是否发生异常，finally块中的代码都会执行。这意味着无论try块成功完成还是在执行过程中发生异常并跳转到catch块，finally块中的代码都将在方法返回之前执行。

2. 资源清理： finally块通常用于执行清理工作，比如关闭打开的文件、释放网络资源或清理任何释放的系统资源。即使在try或catch块中有return语句或抛出了异常，finally块仍保证这些资源被妥善处理。

3. 避免资源泄露： 如果没有finally块，异常可能会导致方法突然结束，这样可能会产生未关闭的资源或未完成的状态更新。通过在finally块中关闭和清理资源，你可以避免资源泄露，即使在异常发生时。

理解这一节的关键是抓住finally块的这些核心概念，并明白它为什么是一个好的编程实践，尤其是在需要确保某些代码无论如何都要执行的情况下。

举例说明，假设你有一段代码用于读取文件：

try {
    // 尝试打开文件，并读取内容
} catch (IOException e) {
    // 处理文件不存在或其他IO异常
} finally {
    // 无论读取成功还是异常发生，都会执行的代码
    // 比如这里可以确保文件被关闭，资源被释放
}

在这个例子中，无论文件读取是否成功，或者是否遇到了一个IOException，finally块都保证了文件会被关闭。这避免了可能会导致内存泄露或文件句柄泄露的风险。

总结：finally的使用是一个最佳实践，用于确保代码的健壮性和资源的正确管理。

 

 总结：

重点：

1. try-catch-finally结构： 理解try块用于包含可能抛出异常的代码，catch块用于处理异常，而finally块用于执行不管是否发生异常都需要执行的代码。

2. 异常的捕获与处理： 掌握如何使用catch来捕获不同类型的异常，并对它们进行处理。

3. 资源管理： 理解finally块在资源管理中的作用，如关闭文件、释放数据库连接等，确保资源在程序结束时被妥善处理。

4. 流程控制： 明白当try块和catch块中有return语句时，finally块仍然会执行。

难点：

1. 异常处理的顺序： 理解当有多个catch块时，异常匹配的顺序和捕获的原则（先子类后父类）。

2. finally块的行为： 理解finally块在不同情况下的执行行为，尤其是与return语句和System.exit()语句共用时的特殊情况。

3. 异常信息的获取： 掌握如何使用e.getMessage()或其他方法获取异常的详细信息。

易错点：

1. 忽略异常处理： 忽视异常处理，导致程序在遇到异常时行为不确定或崩溃。

2. 错误的catch块顺序： 将父类异常的catch块放在子类异常的前面，导致子类异常永远不会被捕获。

3. 在finally中改变返回值： 如果在finally块中修改了返回值或执行了return，可能会覆盖try或catch块中的返回值，这可能导致意外的行为。

4. 在finally块中引发新异常： 如果finally块抛出异常，它会覆盖try和catch块中可能抛出的异常。

5. 过度依赖finally： 误以为finally块在任何情况下都会执行。如果在try或catch块中调用了System.exit()，则finally块不会执行。

通过练习编写和测试不同的异常处理代码，我们可以更深入地理解这些重点、难点和易错点，并且在实际编程时避免这些错误。