Java 认识异常

一、异常的本质与分类

（一）什么是异常？

异常是程序在运行过程中发生的不正常情况，它打破了程序的正常执行流程。异常可以由多种原因引起，例如输入错误、资源不可用、网络故障、代码错误等。当异常发生时，程序需要采取适当的措施来处理它，以避免程序崩溃或产生不可预测的结果。

（二）异常的分类

1. Checked Exception（受检异常）：这类异常在编译时必须被处理，否则程序无法通过编译。例如 IOException、SQLException 等。受检异常通常表示一些可以预期的问题，例如文件读取失败、数据库连接错误等。程序员需要在代码中显式地处理这些异常，要么使用 try-catch 语句捕获并处理它们，要么在方法签名中使用 throws 关键字声明该方法可能抛出这些异常，让调用者来处理。
2. Unchecked Exception（非受检异常）：这类异常在运行时可能发生，但不需要在编译时进行处理。例如 NullPointerException、ArrayIndexOutOfBoundsException 等。非受检异常通常表示程序中的错误，例如空指针引用、数组越界访问等。虽然程序员可以选择捕获和处理这些异常，但通常情况下，这些异常应该被视为程序中的错误，并进行修复。

二、异常处理机制的核心组件

（一）try-catch 语句

1. 基本结构：

• try 块：包含可能抛出异常的代码。当 try 块中的代码执行时，如果发生异常，程序会立即停止执行 try 块中的后续代码，并跳转到相应的 catch 块中进行处理。
• catch 块：用于捕获并处理特定类型的异常。可以有多个 catch 块，每个 catch 块对应一种特定类型的异常。当异常发生时，程序会按照 catch 块的顺序依次进行匹配，找到第一个匹配的 catch 块进行处理。
• finally 块（可选）：无论是否发生异常，finally 块中的代码都会被执行。通常用于释放资源，例如关闭文件、数据库连接等。

2. 异常处理的流程：

• 当程序执行到 try 块中的代码时，如果没有发生异常，程序会继续执行 try 块中的后续代码，然后跳过所有的 catch 块，直接执行 finally 块（如果有）中的代码。
• 如果在 try 块中发生了异常，程序会立即停止执行 try 块中的后续代码，并开始查找与之匹配的 catch 块。如果找到了匹配的 catch 块，程序会跳转到该 catch 块中进行处理。在 catch 块中，可以进行错误处理、记录日志、向用户显示错误信息等操作。
• 无论是否在 try 块中发生异常，finally 块中的代码都会被执行。finally 块中的代码通常用于释放资源、清理现场等操作，以确保程序的稳定性和可靠性。

（二）throws 关键字

1. 作用：用于声明方法可能抛出的异常。如果一个方法可能抛出 Checked Exception，那么必须在方法签名中使用 throws 关键字声明该异常，以便调用者能够处理该异常。
2. 使用场景：当一个方法内部调用了其他可能抛出 Checked Exception 的方法时，如果不想在当前方法中处理这些异常，可以使用 throws 关键字将这些异常向上抛出，让更上层的代码来处理。例如：

public void methodA() throws IOException {
    // 方法体中可能抛出 IOException
}
 
public void methodB() {
    try {
        methodA();
    } catch (IOException e) {
        // 处理 IOException
    }
}

在上面的例子中，methodA 方法使用 throws 关键字声明了它可能抛出 IOException。在 methodB 方法中，调用了 methodA 方法，并在 try-catch 语句中捕获并处理了 IOException。

（三）finally 块

1. 重要性：无论是否发生异常，finally 块中的代码都会被执行。这使得 finally 块成为了释放资源、清理现场的理想场所。例如，在进行文件操作、数据库连接等资源密集型操作时，必须确保在操作完成后及时释放资源，以避免资源泄漏和性能问题。finally 块提供了一种可靠的方式来确保这些资源被正确释放。
2. 使用注意事项：在 finally 块中，应该避免再次抛出异常，否则会掩盖原始异常，使得错误难以排查。如果在 finally 块中必须抛出异常，应该将原始异常包含在新的异常中，以便于调试和错误排查。

三、异常处理的最佳实践

（一）只捕获能够处理的异常

1. 避免捕获所有异常：不要捕获所有类型的异常，只捕获那些能够实际处理的异常。如果捕获了过多的异常，可能会导致代码变得复杂、难以理解，并且可能会隐藏一些真正的问题。例如，不要使用以下代码：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 处理所有异常
}

   2. 针对性处理异常：根据具体的业务需求，选择捕获特定类型的异常。如果无法处理某个异常，最好将其向上抛出，让更上层的代码来处理。例如：

try {
    // 可能抛出 IOException 和 SQLException 的代码
} catch (IOException e) {
    // 处理 IOException
} catch (SQLException e) {
    // 处理 SQLException
}

二）提供有意义的异常信息

异常信息的重要性：在抛出异常时，应该提供有意义的异常信息，以便于调试和错误排查。异常信息应该清晰地描述异常发生的原因、位置和上下文信息。例如：

if (file == null) {
    throw new FileNotFoundException("文件不存在：" + filePath);
}

包含上下文信息：可以在异常信息中包含一些上下文信息，例如方法名、参数值等，以便于更好地理解异常发生的情况。例如：

try {
    int result = divide(a, b);
} catch (ArithmeticException e) {
    throw new CustomException("在方法 divide 中，除数为 0，参数 a = " + a + ", b = " + b);
}

（三）避免空的 catch 块

1. 空 catch 块的问题：空的 catch 块会隐藏异常，使得问题难以发现和解决。如果确实不需要处理某个异常，可以将其重新抛出或者记录下来。例如：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 不要使用空的 catch 块
}

1. 记录异常信息：如果不想处理某个异常，可以使用日志记录工具将异常信息记录下来，以便于后续的错误排查。例如：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    logger.error("发生异常：", e);
}

1. （四）使用多个 catch 块

按照异常类型进行捕获：如果可能发生多种类型的异常，可以使用多个 catch 块来分别处理不同类型的异常。按照异常的具体类型进行捕获，从具体到一般的顺序排列。例如：

try {
    // 可能抛出 IOException 和 SQLException 的代码
} catch (IOException e) {
    // 处理 IOException
} catch (SQLException e) {
    // 处理 SQLException
} catch (Exception e) {
    // 处理其他类型的异常
}

避免重复处理异常：在多个 catch 块中，要避免重复处理异常。如果一个异常已经在前面的 catch 块中被处理了，就不要再在后面的 catch 块中再次处理它。

（五）不要滥用异常

异常的正确用途：异常处理应该用于处理真正的异常情况，而不是用于控制程序的正常流程。如果可以通过其他方式处理错误，例如返回错误码或者设置标志位，那么就不要使用异常。例如：

if (input < 0) {
    // 不要使用异常来处理正常的业务逻辑错误
    throw new IllegalArgumentException("输入值不能为负数");
}

性能考虑：频繁地抛出和捕获异常会影响程序的性能。因此，在编写代码时，应该尽量避免不必要的异常处理。

四、自定义异常

（一）为什么需要自定义异常？

在实际的开发过程中，有时候现有的异常类型不能满足我们的需求。例如，我们可能需要定义一些特定于业务领域的异常，以便更好地描述和处理特定的错误情况。自定义异常可以提供更清晰的错误信息，提高代码的可读性和可维护性。

（二）自定义异常的实现

1. 继承 Exception 类：自定义异常类应该继承自 Exception 或其子类。如果自定义的异常是受检异常，应该继承自 Exception；如果是非受检异常，应该继承自 RuntimeException。例如：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

1. 提供构造函数：自定义异常类应该提供至少一个构造函数，以便在抛出异常时传递错误信息。构造函数可以接受一个字符串参数，作为异常的错误信息。例如：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}
 
throw new CustomException("发生了自定义异常");

1. 添加额外的方法和属性：根据需要，可以在自定义异常类中添加一些额外的方法和属性，以便更好地描述和处理异常情况。例如，可以添加一个方法来获取错误码，或者添加一个属性来记录错误发生的时间。

public class CustomException extends Exception {
    private int errorCode;
 
    public CustomException(String message, int errorCode) {
        super(message);
        this.errorCode = errorCode;
    }
 
    public int getErrorCode() {
        return errorCode;
    }
}
 
throw new CustomException("发生了自定义异常", 123);

五、总结

Java 的异常处理机制是一种强大的工具，它能够帮助我们有效地管理程序中的错误情况，提高程序的稳定性、可靠性和可维护性。通过合理地使用 try-catch 语句、throws 关键字和 finally 块，以及遵循异常处理的最佳实践，我们可以更好地处理程序中的异常情况，确保程序的正确运行。同时，自定义异常类也可以让我们更好地描述和处理特定的业务错误，提高代码的可读性和可维护性。在实际编程中，我们应该充分利用 Java 的异常处理机制，以确保程序的质量和稳定性。

完！