23、Java 异常处理与资源管理全解析-优快云博客

本文链接：https://blog.youkuaiyun.com/read5/article/details/149371512

Java 异常处理与资源管理全解析

在 Java 编程中，异常处理和资源管理是非常重要的部分。异常可能会在程序运行时突然出现，打乱程序的正常执行流程；而资源管理不当则可能导致资源泄漏等问题。下面我们将详细探讨 Java 中的异常处理和资源管理。

异常处理基础

在 Java 中，异常是指程序运行时出现的错误或意外情况。当我们复制字节从 dataIn 到 dataOut 时，通常会使用 while 循环。这个 while 循环看似会无限执行，但当到达 dataIn 文件的末尾时， readByte 方法会抛出一个 EOFException （文件结束异常）。这个异常的抛出会使程序跳出 try 子句和 while 循环，然后进入 catch 子句进行相应处理，之后再继续正常的程序流程。

例如，我们来看一个简单的程序，它尝试让程序暂停 5 秒钟：

/*
 * This code does not compile.
 */
import static java.lang.System.out;
class NoSleepForTheWeary {
    public static void main(String args[]) {
        out.print("Excuse me while I nap ");
        out.println("for just five seconds...");
        takeANap();
        out.println("Ah, that was refreshing.");
    }
    static void takeANap() {
        Thread.sleep(5000);
    }
}

上述代码在编译时会报错，因为 Thread.sleep 方法可能会抛出 InterruptedException 异常。这个异常属于 Java 中的受检查异常（checked exception），意味着在调用可能抛出该异常的方法时，必须在代码中对其进行处理。

Java 中的异常分为受检查异常和非受检查异常（unchecked exception）：
- 受检查异常 ：潜在抛出的受检查异常必须在代码中进行处理，通常通过 try-catch 语句或在方法头中使用 throws 子句声明。
- 非受检查异常 ：潜在抛出的非受检查异常不需要在代码中进行处理。

InterruptedException 就是一个受检查异常的例子。当调用 Thread.sleep 方法时，必须对可能抛出的 InterruptedException 进行处理。处理受检查异常有两种常见的方式：
1. 使用 try-catch 语句 ：将可能抛出异常的语句放在 try 子句中，并在 catch 子句中捕获并处理相应的异常。

import static java.lang.System.out;
class GoodNightsSleepA {
    public static void main(String args[]) {
        out.print("Excuse me while I nap ");
        out.println("for just five seconds...");
        takeANap();
        out.println("Ah, that was refreshing.");
    }
    static void takeANap() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            out.println("Hey, who woke me up?");
        }
    }
}

使用 throws 子句 ：在方法头中声明该方法可能抛出的异常，将处理异常的责任传递给调用该方法的代码。

import static java.lang.System.out;
class GoodNightsSleepB {
    public static void main(String args[]) {
        out.print("Excuse me while I nap ");
        out.println("for just five seconds...");
        try {
            takeANap();
        } catch (InterruptedException e) {
            out.println("Hey, who woke me up?");
        }
        out.println("Ah, that was refreshing.");
    }
    static void takeANap() throws InterruptedException {
        Thread.sleep(5000);
    }
}

下面是异常处理的流程图：

graph TD;
    A[调用可能抛出异常的方法] --> B{是否抛出异常};
    B -- 是 --> C[进入catch子句处理异常];
    B -- 否 --> D[继续正常执行];
    C --> D;

异常处理的更多细节

一个方法可以在其 throws 子句中声明多个异常类型，只需用逗号分隔这些异常类型的名称，例如：

throws InterruptedException, IOException, ArithmeticException

Java API 中有数百种异常类型，其中一些是 RuntimeException 类的子类。任何 RuntimeException 的子类（包括子子类等）都是非受检查异常，而其他不是 RuntimeException 后代的异常则是受检查异常。非受检查异常包括一些计算机难以预测的情况，如 NumberFormatException 、 ArithmeticException 、 IndexOutOfBoundsException 、 NullPointerException 等。在编写 Java 代码时，虽然很多代码可能会受到这些异常的影响，但将代码放在 try 子句中处理（或使用 throws 子句传递责任）是完全可选的。而受检查异常，如 InterruptedException 、 IOException 、 SQLException 等，Java 要求必须对其进行处理。

`finally` 子句的使用

在异常处理中，我们还需要考虑一种情况：当程序在处理一个异常时，可能会抛出第二个异常。为了应对这种情况，我们可以使用 finally 子句。 finally 子句跟在 try 子句之后，与 catch 子句不同的是，无论是否抛出异常， finally 子句中的语句都会被执行。

下面是一个使用 finally 子句的例子：

import static java.lang.System.out;
class DemoFinally {
    public static void main(String args[]) {
        try {
            doSomething();
        } catch (Exception e) {
            out.println("Exception caught in main.");
        }
    }
    static void doSomething() {
        try {
            out.println(0 / 0);
        } catch (Exception e) {
            out.println(
              "Exception caught in doSomething.");
            out.println(0 / 0);
        } finally {
            out.println("I’ll get printed.");
        }
        out.println("I won’t get printed.");
    }
}

在上述代码中， doSomething 方法首先尝试执行 out.println(0 / 0) ，这会抛出一个 ArithmeticException 异常，该异常被 catch 子句捕获。在 catch 子句中，又执行了一次 out.println(0 / 0) ，再次抛出异常。但无论如何， finally 子句中的 out.println("I’ll get printed.") 都会被执行。而 out.println("I won’t get printed.") 由于异常的抛出，不会被执行。

文件资源管理

在 Java 编程中，文件资源的管理也非常重要。如果在程序中打开了一个文件，但没有在使用完后关闭它，可能会导致资源泄漏。例如，在早期的一些程序中，可能会打开一个文件进行读取操作，但没有显式地关闭文件：

Scanner diskScanner = new Scanner(new File("EmployeeInfo.txt"));

为了避免资源泄漏，我们需要在使用完文件后关闭它。可以在程序的 main 方法末尾添加如下代码：

diskScanner.close();

更好的策略是在最后一次使用文件后立即调用 close 方法。

然而，普通的 close 方法调用可能会出现问题。例如，在程序执行过程中，如果在调用 close 方法之前出现异常，程序可能会提前终止，导致文件没有被关闭。为了解决这个问题，Java 7 引入了 try-with-resources 语句。

下面是一个使用 try-with-resources 语句的例子：

import java.util.Scanner;
import java.io.File;
import java.io.IOException;
class DoPayroll {
    public static void main(String args[]) throws IOException {
        try (Scanner diskScanner = new Scanner(new File("EmployeeInfo.txt"))) {
            for (int empNum = 1; empNum <= 3; empNum++) {
                payOneEmployee(diskScanner);
            }
        }        
    }
    static void payOneEmployee(Scanner aScanner) {
        Employee anEmployee = new Employee();
        anEmployee.setName(aScanner.nextLine());
        anEmployee.setJobTitle(aScanner.nextLine());
        anEmployee.cutCheck(aScanner.nextDouble());
        aScanner.nextLine();
    }
}

在上述代码中， Scanner 对象的声明放在 try 关键字后面的括号中。这告诉 Java 7 在 try 子句中的语句执行完毕后，自动关闭 diskScanner 。如果需要使用多个资源，也可以在 try 语句的括号中声明多个资源，Java 7 会在执行完 try 子句后自动关闭所有资源。同时，还可以根据需要添加 catch 子句和 finally 子句。

文件资源管理的步骤如下：
1. 使用 Scanner 或其他文件操作类打开文件。
2. 使用 try-with-resources 语句确保文件在使用完后自动关闭。
3. 在 try 子句中进行文件操作。

通过以上方法，我们可以更好地处理 Java 中的异常和资源管理，避免程序出现不必要的错误和资源泄漏问题。

Java 异常处理与资源管理全解析

异常处理与资源管理的综合应用

在实际的 Java 编程中，异常处理和资源管理往往是相互关联的。我们可以通过一个更复杂的例子来展示它们的综合应用。

假设我们需要从一个文件中读取数据，并对数据进行处理。在这个过程中，可能会出现文件不存在、读取数据错误等异常情况，同时我们需要确保文件资源在使用完后被正确关闭。

import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;

class DataProcessor {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(new File("data.txt"))) {
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                processLine(line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件未找到: " + e.getMessage());
        }
    }

    static void processLine(String line) {
        try {
            // 模拟数据处理过程，可能会抛出异常
            int number = Integer.parseInt(line);
            System.out.println("处理的数据: " + number);
        } catch (NumberFormatException e) {
            System.out.println("数据格式错误: " + e.getMessage());
        }
    }
}

在上述代码中，我们使用了 try-with-resources 语句来确保 Scanner 对象在使用完后自动关闭。同时，在 main 方法中捕获了 FileNotFoundException 异常，处理文件未找到的情况。在 processLine 方法中，捕获了 NumberFormatException 异常，处理数据格式错误的情况。

下面是这个程序的执行流程图：

graph TD;
    A[开始] --> B[打开文件];
    B --> C{文件是否存在};
    C -- 是 --> D[逐行读取文件];
    C -- 否 --> E[捕获FileNotFoundException并处理];
    D --> F{是否还有下一行};
    F -- 是 --> G[处理当前行];
    F -- 否 --> H[关闭文件];
    G --> I{数据格式是否正确};
    I -- 是 --> D;
    I -- 否 --> J[捕获NumberFormatException并处理];
    J --> D;
    E --> K[结束];
    H --> K;

异常处理和资源管理的最佳实践

为了更好地进行异常处理和资源管理，我们可以遵循以下最佳实践：
1. 明确异常类型 ：在捕获异常时，尽量明确异常的类型，避免使用通用的 Exception 类型。这样可以更精确地处理不同类型的异常。
2. 使用 try-with-resources 语句 ：对于需要管理的资源，如文件、数据库连接等，优先使用 try-with-resources 语句，确保资源在使用完后自动关闭。
3. 合理传递异常 ：在方法中，如果无法处理某个异常，可以使用 throws 子句将异常传递给调用者。但要确保调用者能够正确处理该异常。
4. 记录异常信息 ：在捕获异常时，记录异常的详细信息，如异常类型、异常消息等，方便后续的调试和维护。

总结

本文详细介绍了 Java 中的异常处理和资源管理。我们了解了 Java 中的受检查异常和非受检查异常，以及处理受检查异常的两种常见方式： try-catch 语句和 throws 子句。同时，介绍了 finally 子句的使用，它可以确保无论是否抛出异常，其中的语句都会被执行。在文件资源管理方面，我们学习了如何使用 try-with-resources 语句来避免资源泄漏。

通过遵循异常处理和资源管理的最佳实践，我们可以编写出更健壮、更可靠的 Java 程序。

异常类型	处理方式	示例
受检查异常	`try-catch` 语句或 `throws` 子句	`Thread.sleep` 抛出的 `InterruptedException`
非受检查异常	可选处理	`NumberFormatException` 、 `ArithmeticException` 等