22、Java 异常处理全解析-优快云博客

本文链接：https://blog.youkuaiyun.com/a0b1c2d3/article/details/149371806

Java 异常处理全解析

1. 异常概述

异常是程序运行过程中出现的错误情况。在 Java 中，异常以对象的形式存在，并且所有异常类都继承自 java.lang.Throwable 类。异常处理机制的关键在于不仅要识别异常，还要决定在发现异常后如何处理。

栈跟踪信息能帮助我们定位异常。例如，当出现 ArrayIndexOutOfBoundsException 时，栈跟踪信息会显示异常发生在“主线程”，并指出越界的索引。像下面的栈跟踪信息：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
        at YourClass.main(YourClass.java:10)

这表明在尝试访问数组的第一个元素（索引为 0）时出现了异常，因为数组可能为空。

为了避免异常，我们可以在代码中添加条件判断。比如，在访问数组元素之前，先检查数组的长度：

if (array.length > 0) {
    // 访问数组元素
} else {
    System.err.println("数组为空，无法访问元素。");
}

2. 异常层次结构

Java 中的异常类形成了一个层次结构，主要分为以下几类：
| 异常类 | 描述 |
| ---- | ---- |
| java.lang.Throwable | 所有异常类的基类，包含 printStackTrace() 和 getMessage() 等方法。 |
| java.lang.Error | 表示严重的错误，通常是 JVM 内部问题，程序无法处理，如 OutOfMemoryError 。 |
| java.lang.Exception | 表示程序运行过程中出现的逻辑问题，很多情况下可以通过用户干预或代码逻辑恢复。 |
| java.lang.RuntimeException | 是 Exception 的子类，属于未检查异常，编译器不会强制要求处理。 |

下面是异常层次结构的 mermaid 流程图：

graph TD;
    A[java.lang.Object] --> B[java.lang.Throwable];
    B --> C[java.lang.Error];
    B --> D[java.lang.Exception];
    D --> E[java.lang.RuntimeException];

3. 检查异常和未检查异常

检查异常（Checked Exception） ：编译器会强制要求代码处理这类异常。所有检查异常都继承自 java.lang.Exception 类，但不继承自 java.lang.RuntimeException 类。例如，在读取文件时可能会抛出 FileNotFoundException ，编译器会提示我们必须处理这个异常。

try {
    java.io.FileInputStream fis = new java.io.FileInputStream("file.txt");
} catch (java.io.FileNotFoundException e) {
    System.err.println("文件未找到：" + e.getMessage());
}

未检查异常（Unchecked Exception） ：继承自 java.lang.RuntimeException 类，编译器不会强制要求处理。例如， NullPointerException 就是一个常见的未检查异常。

4. 使用 try 和 catch 处理异常

try 和 catch 关键字用于创建异常处理块。 try 块中的代码被称为受保护代码，JVM 会监控其中的语句执行情况。如果出现异常，JVM 会尝试找到匹配的 catch 块来处理异常。

try/catch 块的一般语法如下：

try {
    // 可能抛出异常的方法调用
} catch (ExceptionClass name) {
    // 处理异常的代码
}

例如，使用 Integer.parseInt() 方法时，如果输入的字符串不是有效的整数，会抛出 NumberFormatException ：

public class SquareIt {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java SquareIt <number>");
            System.exit(1);
        }
        int num;
        try {
            num = Integer.parseInt(args[0]);
        } catch (NumberFormatException nfe) {
            num = 1;
        }
        System.out.println(num + " squared is " + (num * num));
    }
}

在这个例子中，如果输入的参数不是有效的整数， catch 块会将 num 的值设为 1，确保程序能继续运行。

5. 异常对流程的影响

异常会改变程序的执行流程。当 try 块中出现异常时，控制会立即转移到匹配的 catch 块， try 块中剩余的语句将被跳过。

例如，下面的代码在 try 块中添加了额外的输出语句：

public class SquareItAgain {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java SquareItAgain <number>");
            System.exit(1);
        }
        int num;
        try {
            num = Integer.parseInt(args[0]);
            System.out.println("No problem!");
        } catch (NumberFormatException nfe) {
            num = 1;
        }
        System.out.println(num + " squared is " + (num * num));
    }
}

如果输入的参数不是有效的整数， System.out.println("No problem!"); 语句将不会执行。

6. 添加多个 catch 块

一个 try 块可以关联多个 catch 块，用于处理不同类型的异常。例如：

try {
    methodA(); // 可能抛出 OneException
    methodB(); // 可能抛出 AnotherException
} catch (OneException oe) {
    // 处理 OneException
} catch (AnotherException ae) {
    // 处理 AnotherException
}

在这个例子中，如果 methodA() 抛出 OneException ，第一个 catch 块会执行；如果 methodB() 抛出 AnotherException ，第二个 catch 块会执行。

7. 正确排序异常

由于检查异常和未检查异常都继承自 Exception 类，我们需要正确排序 catch 块。第一个匹配异常类型的 catch 块将被执行。

例如，下面的代码中，如果 methodA() 抛出 OneException ，第一个 catch 块会执行：

try {
    methodA();
} catch (Exception ex) {
    System.err.println(ex.getMessage());
} catch (OneException oe) {
    System.err.println(oe.getMessage());
}

为了确保正确处理异常，应该将更具体的异常类型放在前面，更通用的异常类型放在后面：

try {
    methodA();
} catch (OneException oe) {
    System.err.println(oe.getMessage());
} catch (Exception ex) {
    // 处理除 OneException 之外的其他异常
    System.err.println(ex.getMessage());
}

8. 使用 finally 子句

finally 子句用于确保某些代码无论是否发生异常都会执行。通常用于释放外部资源，如关闭文件、数据库连接等。

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

public class SquareItFinally {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java SquareItFinally <number>");
            System.exit(1);
        }
        int num;
        try {
            num = Integer.parseInt(args[0]);
            System.out.println("No problem!");
        } catch (NumberFormatException nfe) {
            num = 1;
        } finally {
            System.out.println("This always prints out.");
        }
        System.out.println(num + " squared is " + (num * num));
    }
}

在这个例子中，无论 try 块中是否发生异常， finally 块中的语句都会执行。

即使在 try 块中使用 return 语句， finally 块也会在返回之前执行：

try {
    num = Integer.parseInt(args[0]);
    return;
} catch (NumberFormatException nfe) {
    num = 1;
} finally {
    System.out.println("This always (and I mean always) prints out!");
}

通过合理使用 try 、 catch 和 finally 关键字，我们可以编写更健壮的 Java 程序，有效地处理各种异常情况。

Java 异常处理全解析（续）

9. 异常处理的最佳实践

在 Java 中进行异常处理时，有一些最佳实践可以帮助我们编写更健壮、高效的代码。
- 避免不必要的异常处理 ：异常处理机制会给代码处理带来一定的开销，因此应尽量避免潜在的异常。例如，在访问数组元素之前先检查数组长度，避免 ArrayIndexOutOfBoundsException 。
- 具体异常优先处理 ：在使用多个 catch 块时，将更具体的异常类型放在前面，通用的异常类型放在后面，确保正确捕获和处理异常。
- 使用 finally 释放资源 ：对于需要手动释放的资源，如文件、数据库连接等，使用 finally 子句确保资源一定会被释放。

下面是一个综合示例，展示了如何应用这些最佳实践：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ResourceHandlingExample {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("example.txt");
            // 读取文件内容
            int data;
            while ((data = fis.read()) != -1) {
                // 处理数据
            }
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到：" + e.getMessage());
        } catch (IOException e) {
            System.err.println("读取文件时出错：" + e.getMessage());
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    System.err.println("关闭文件时出错：" + e.getMessage());
                }
            }
        }
    }
}

10. 自定义异常

除了 Java 提供的标准异常类型，我们还可以创建自定义异常类。自定义异常类通常继承自 Exception 或其子类。

以下是创建自定义异常类的步骤：
1. 定义异常类 ：创建一个新的类，继承自 Exception 或 RuntimeException 。
2. 添加构造方法 ：可以添加无参构造方法和带消息参数的构造方法。

示例代码如下：

// 自定义异常类
class CustomException extends Exception {
    public CustomException() {
        super();
    }

    public CustomException(String message) {
        super(message);
    }
}

// 使用自定义异常的示例
public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new CustomException("这是一个自定义异常。");
        } catch (CustomException e) {
            System.err.println(e.getMessage());
        }
    }
}

11. 异常处理的流程图总结

下面是一个 mermaid 流程图，总结了 Java 异常处理的基本流程：

graph TD;
    A[开始] --> B[执行 try 块代码];
    B --> C{是否发生异常};
    C -- 是 --> D[查找匹配的 catch 块];
    D --> E[执行 catch 块代码];
    E --> F[执行 finally 块代码];
    C -- 否 --> F;
    F --> G[继续执行后续代码];
    G --> H[结束];

12. 异常处理的常见错误及解决方法

在进行异常处理时，可能会遇到一些常见的错误。以下是这些错误及相应的解决方法：
| 错误类型 | 错误描述 | 解决方法 |
| ---- | ---- | ---- |
| 异常捕获顺序错误 | 通用异常类型的 catch 块放在了具体异常类型之前，导致具体异常无法被正确捕获。 | 调整 catch 块的顺序，将具体异常类型放在前面。 |
| 资源未正确释放 | 在 try 块中打开的资源（如文件、数据库连接）没有在 finally 块中正确释放。 | 使用 finally 子句确保资源一定会被释放。 |
| 异常信息丢失 | 在捕获异常后，没有记录或处理异常信息，导致难以调试。 | 在 catch 块中记录异常信息，如使用 System.err.println 或日志框架。 |

13. 总结

Java 异常处理是编写健壮程序的重要组成部分。通过理解异常的层次结构、使用 try 、 catch 和 finally 关键字，以及遵循最佳实践，我们可以有效地处理各种异常情况。同时，自定义异常可以让我们根据具体业务需求更好地处理特定的错误。在实际开发中，要注意异常处理的顺序、资源的释放和异常信息的记录，避免常见的错误，从而提高代码的可靠性和可维护性。

在日常编程中，多实践、多总结，不断积累异常处理的经验，将有助于我们编写出更加稳定、高效的 Java 程序。