- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

💥 深入探索 Java 异常类：让你编程不再“崩溃”！ 🚀

bug菌发表于 2024/11/29 09:26:43 2024/11/29

【摘要】前言：异常背后的“危机”和“机会” 💡在软件开发的世界里，程序崩溃往往意味着灾难，而异常则是我们与灾难斗争的武器。你可能会觉得，异常处理就是简单地用 try-catch 捕捉一下，程序就能“正常”运行了。然而，现实远没有那么简单。异常的处理不仅仅是为了捕捉错误，更是为了让你的程序在“危机四伏”的环境中依旧能稳定运行，甚至优雅地恢复。正如一个演员面对突如其来的台词忘记时，如何快速反应并继续...

前言：异常背后的“危机”和“机会” 💡

在软件开发的世界里，程序崩溃往往意味着灾难，而异常则是我们与灾难斗争的武器。你可能会觉得，异常处理就是简单地用 try-catch 捕捉一下，程序就能“正常”运行了。然而，现实远没有那么简单。异常的处理不仅仅是为了捕捉错误，更是为了让你的程序在“危机四伏”的环境中依旧能稳定运行，甚至优雅地恢复。正如一个演员面对突如其来的台词忘记时，如何快速反应并继续演出，这就是异常机制的魅力所在。

在 Java 中，异常类不仅仅是错误的代名词，它们有自己的体系，包含不同层次的“角色”，从可以忽略的小错误到无法抗拒的大灾难，每个异常都有其独特的处理方式。今天，我们将深入了解 Java 中的异常类，解开这背后的神秘面纱，帮助你成为异常处理的高手！

异常类的体系：从错误到异常，层次分明 🧐

Java 的异常体系是非常清晰的，每一个异常类都是继承自 Throwable 类的。简单地说，Throwable 类就是异常类的“祖先”，而它下面有两个主要的“子孙”：

Error：表示严重的错误，通常是系统层面的问题，程序无法从这些错误中恢复。比如，JVM 内存不足或栈溢出等错误。
Exception：这是我们平时最常接触到的类，代表程序中出现的异常。它又分为检查型异常（Checked Exception）和非检查型异常（Unchecked Exception）。

1. Error 类：无法抗拒的“天灾”

Error 类通常代表那些程序无法处理的严重错误，这些错误一般是由 Java 虚拟机（JVM）自身或者操作系统引发的。比如 OutOfMemoryError 和 StackOverflowError，它们代表了内存溢出或者栈溢出的情况。我们通常不会去捕获这些错误，因为它们意味着程序运行环境出现了根本性的问题，程序基本无法继续运行。

// 内存溢出错误示例
try {
    List<Integer> list = new ArrayList<>();
    while (true) {
        list.add(1); // 不断添加，直到内存溢出
    }
} catch (OutOfMemoryError e) {
    System.out.println("内存溢出！赶紧退出！");
}

代码解析：

在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

我提供的代码是一个模拟 内存溢出 错误的示例，代码的作用是不断地向一个 ArrayList 中添加元素，直到 JVM 内存耗尽，从而抛出 OutOfMemoryError 错误。

创建 ArrayList：
- List<Integer> list = new ArrayList<>(); 创建了一个空的 ArrayList，用于存储整数。
无限循环：
- while (true) { list.add(1); } 是一个无限循环，每次循环都往 list 中添加一个元素 1。因为没有停止条件，程序会持续往列表中添加元素。
内存溢出：
- 当 ArrayList 中的元素越来越多，程序占用的内存逐渐增加。最终，JVM 的堆内存会被填满，无法继续分配空间，抛出 OutOfMemoryError 错误。
异常捕获：
- catch (OutOfMemoryError e) 捕获 OutOfMemoryError 异常，并输出 "内存溢出！赶紧退出！" 提示信息。

内存溢出的原因：

无限增长的 ArrayList：ArrayList 是一个动态数组，当它的容量不足时，会自动扩展数组，但扩展的过程会消耗越来越多的内存。在没有限制的情况下，内存最终会用尽。
没有退出机制：由于 while (true) 是一个无限循环，它会一直执行，直到 JVM 无法分配更多内存。

解决内存溢出：

合理设置内存大小：你可以通过 JVM 启动参数来设置最大堆内存大小，使用 -Xmx 来限制最大内存。
- 例如，java -Xmx512m 可以将最大堆内存设置为 512MB。
控制数据添加量：避免无限制地添加数据，应该为数据添加设置合理的上限，或者使用 ArrayList 的初始容量进行优化。
垃圾回收：定期检查内存使用，确保对象不再使用时被清理，避免内存泄漏。
分配内存时进行监控：在开发中，使用工具（如 JProfiler、VisualVM）监控 JVM 的内存使用，确保不会因内存使用过多而导致 OutOfMemoryError。

示例优化：
在实际应用中，应避免无限制的内存分配，例如：

// 防止内存溢出的优化
List<Integer> list = new ArrayList<>();
int maxSize = 1000000; // 限制最大元素数量
for (int i = 0; i < maxSize; i++) {
    list.add(1); // 添加元素
}

这样可以控制内存的使用，避免无限制的内存消耗。

小结：

内存溢出错误（OutOfMemoryError）通常发生在 JVM 无法为应用程序分配足够的内存时，通常是因为程序中有无限增长的数据结构或内存泄漏。
使用合适的内存管理策略，避免无限添加数据或使用过多的内存，可以有效减少内存溢出错误的发生。

2. Exception 类：程序中的“意外”

与 Error 类不同，Exception 类代表程序运行中的意外事件。虽然这些异常是程序员可以处理的，但它们往往表明程序的某个部分没有按照预期运行。Java 中的异常几乎全部继承自 Exception 类，而 Exception 又细分为检查型异常（Checked Exception）和非检查型异常（Unchecked Exception）两大类。

2.1 检查型异常（Checked Exception）

检查型异常是程序员必须显式处理的异常。它们通常在编译时就能被检测到，因此开发者需要提前捕获或声明抛出这些异常。比如，文件操作可能抛出 IOException，数据库操作可能抛出 SQLException，这些异常必须被处理，否则程序无法通过编译。

// 例：处理文件读写异常
try {
    FileReader reader = new FileReader("不存在的文件.txt");
} catch (IOException e) {
    System.out.println("文件读取失败！请检查文件路径。");
}

代码解析：

我提供的代码示例展示了如何处理文件读取时的异常。该代码试图读取一个不存在的文件，并在发生异常时捕获并处理。

// 例：处理文件读写异常
try {
    FileReader reader = new FileReader("不存在的文件.txt");
} catch (IOException e) {
    System.out.println("文件读取失败！请检查文件路径。");
}

尝试打开文件：
- FileReader reader = new FileReader("不存在的文件.txt"); 尝试读取一个名为 不存在的文件.txt 的文件。由于文件不存在，会抛出一个 IOException。
捕获异常：
- catch (IOException e) 捕获 IOException 异常，这是文件操作过程中常见的异常类型，例如文件不存在、没有读取权限等。
- 异常捕获后，会执行 catch 块中的代码，输出错误信息 文件读取失败！请检查文件路径。。
异常处理：
- 异常处理机制保证了程序不会因为文件不存在而崩溃，而是输出有用的错误信息，并让程序继续运行。

可能的异常：

FileNotFoundException：当指定的文件不存在时，会抛出 FileNotFoundException，这是 IOException 的子类。
IOException：除了文件不存在外，其他读写过程中可能发生的异常（如文件权限问题）也会抛出此类异常。

优化：

更具体的异常处理：

如果你希望处理更具体的异常类型，可以捕获 FileNotFoundException，它是 IOException 的一个更具体的子类。

try {
    FileReader reader = new FileReader("不存在的文件.txt");
} catch (FileNotFoundException e) {
    System.out.println("文件不存在，请检查文件路径。");
} catch (IOException e) {
    System.out.println("文件读取失败！发生未知错误。");
}

资源管理：
- 使用 try-with-resources 语句可以更方便地管理资源，确保文件流在使用完后自动关闭，避免资源泄漏。
```
try (FileReader reader = new FileReader("不存在的文件.txt")) {
    // 读取文件内容
} catch (IOException e) {
    System.out.println("文件读取失败！请检查文件路径。");
}
```
这可以确保即使发生异常，FileReader 对象也会在 try 块结束时自动关闭。

总结：
通过异常处理，你可以让程序在面对常见的文件读写错误时更加健壮，并确保程序不会因为小错误而中断。适当的异常捕获和具体的错误信息输出能帮助用户及时发现并解决问题。

2.2 非检查型异常（Unchecked Exception）

非检查型异常是程序运行时才可能发生的错误，通常是由于代码逻辑错误导致的，比如空指针异常 NullPointerException，数组下标越界异常 ArrayIndexOutOfBoundsException 等。它们不需要程序员在编译时显式捕获，虽然可以捕获，但更好的做法是通过修改代码逻辑来避免它们的发生。

// 例：空指针异常
String str = null;
try {
    System.out.println(str.length());
} catch (NullPointerException e) {
    System.out.println("你试图访问了空对象！");
}

代码解析：

我提供的代码示例展示了如何处理空指针异常（NullPointerException）的情况。

空对象引用：
- String str = null;：这里将 str 设置为 null，意味着它不指向任何对象。
访问空对象：
- System.out.println(str.length());：尝试访问 str 的 length() 方法。但由于 str 是 null，此时访问它的任何属性或方法都会引发空指针异常 NullPointerException。
异常捕获与处理：
- catch (NullPointerException e)：当 NullPointerException 被抛出时，程序会跳转到 catch 块，并执行该块中的代码。这里输出了提示信息 你试图访问了空对象！。
程序继续执行：
- 捕获异常后，程序不会崩溃，而是打印提示信息并继续执行后续代码。

空指针异常（NullPointerException）是什么？

NullPointerException 是一种常见的运行时异常，发生在以下情况之一：

尝试调用 null 引用的实例方法。
尝试访问或修改 null 引用的实例变量。
使用 null 作为数组的索引。
尝试在 null 上进行自动拆箱操作。

异常的输出：
运行上述代码时，输出将是：

你试图访问了空对象！

优化和改进：

提前检查 null：
在实际开发中，最好在访问对象的属性或方法之前，检查该对象是否为 null，以避免出现空指针异常。
```
String str = null;
if (str != null) {
    System.out.println(str.length());
} else {
    System.out.println("str 是 null，无法访问其属性！");
}
```
这样可以在问题发生之前进行预防，确保程序不会因为 null 引用而抛出异常。
使用 Optional（Java 8 及以上）：
Java 8 引入了 Optional 类，允许你更加优雅地处理可能为 null 的值，避免直接抛出空指针异常。
```
Optional<String> str = Optional.ofNullable(null);
System.out.println(str.map(String::length).orElse(0));  // 返回 0，因为 str 是 null
```
这样可以避免显式的 null 检查，提高代码的可读性和可维护性。

小结：
在遇到空指针异常时，首先要检查对象是否为 null，并在可能的情况下避免访问 null 对象。在编写代码时，推荐使用 Optional 或显式的 null 检查来提升程序的健壮性，从而减少 NullPointerException 的发生。

3. 自定义异常：你也可以成为“异常制造者”

有时，Java 标准库中的异常不足以描述特定的错误场景。这个时候，你可以自己定义异常类，通过继承 Exception 或 RuntimeException 来创建你自己的异常。

// 例：自定义异常
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            checkAge(150);
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void checkAge(int age) throws InvalidAgeException {
        if (age < 0 || age > 120) {
            throw new InvalidAgeException("年龄不合法！");
        }
        System.out.println("年龄合法！");
    }
}

通过自定义异常类，你可以为程序中的特定错误场景设计更合适的异常类型，从而提高程序的可读性和可维护性。

代码解析：

我提供的代码展示了如何自定义异常并在程序中使用。让我们逐步解析这段代码：

自定义异常类：

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);  // 调用父类构造函数，将错误信息传递给 Exception 类
    }
}

InvalidAgeException 继承自 Exception 类，是一个自定义的异常类。构造函数 InvalidAgeException(String message) 会将错误信息传递给 Exception 类的构造函数，这样你就可以在捕获异常时获取到自定义的错误信息。

checkAge 方法：

public static void checkAge(int age) throws InvalidAgeException {
    if (age < 0 || age > 120) {
        throw new InvalidAgeException("年龄不合法！");
    }
    System.out.println("年龄合法！");
}

checkAge 方法用于检查年龄是否合法。
- 如果年龄小于0或者大于120，抛出一个 InvalidAgeException 异常，传递错误信息 "年龄不合法！"。
- 如果年龄合法（0 <= age <= 120），则打印 "年龄合法！"。

调用 checkAge 方法并捕获异常：

public static void main(String[] args) {
    try {
        checkAge(150);  // 这里传入了一个非法的年龄
    } catch (InvalidAgeException e) {
        System.out.println(e.getMessage());  // 捕获异常并输出异常信息
    }
}

在 main 方法中，调用 checkAge(150)，传入了一个非法的年龄 150。
由于 150 超出了合法的年龄范围（0-120），checkAge 会抛出 InvalidAgeException 异常。
异常被 catch 块捕获，e.getMessage() 会输出 "年龄不合法！"。

异常输出：

运行这段代码时，程序会输出：

年龄不合法！

代码的总结：

自定义异常：通过继承 Exception 类，你可以创建自己的异常类型。在这个例子中，我们创建了 InvalidAgeException 来表示年龄不合法的情况。
抛出异常：使用 throw 关键字抛出异常，当发现年龄不合法时，抛出 InvalidAgeException。
捕获异常：在 main 方法中，通过 try-catch 语句捕获自定义的 InvalidAgeException 异常，输出错误信息。

改进和优化：

异常链：如果你在抛出自定义异常时希望保留原始异常信息，可以通过传递 Throwable 类型的参数来创建异常链。例如：

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message, Throwable cause) {
        super(message, cause);
    }
}

日志记录：可以在异常处理中加入日志记录，以便更好地调试和记录错误：

catch (InvalidAgeException e) {
    // 使用日志框架记录异常
    System.err.println("Error: " + e.getMessage());
}

进一步封装：你可以在 InvalidAgeException 中提供更多的构造函数，例如带有错误代码的构造函数，这样可以更细致地处理不同类型的错误。

class InvalidAgeException extends Exception {
    private int errorCode;

    public InvalidAgeException(String message, int errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    public int getErrorCode() {
        return errorCode;
    }
}

小结：
通过自定义异常类，你可以增强程序的可维护性和可读性，捕获并处理特定的错误场景，而不是使用通用的异常类型。自定义异常使得错误处理更加语义化，并且可以传递更多的错误上下文信息。

异常处理：如何优雅地“捕获”程序中的意外 👀

掌握了异常类的分类，接下来我们需要了解如何优雅地处理这些异常。Java 提供了几种常用的异常处理机制：try-catch、throws 和 finally，它们帮助我们捕获异常、声明异常并确保资源清理。

1. try-catch：捕获异常，避免程序崩溃

try-catch 是最常用的异常处理方式。你将可能抛出异常的代码放入 try 块中，然后用 catch 块捕获并处理异常。这样，即使发生了异常，程序也能继续执行，而不会直接崩溃。

try {
    int result = 10 / 0; // 可能抛出除以零异常
} catch (ArithmeticException e) {
    System.out.println("除数不能为零！");
}

2. throws：将异常“甩”给调用者处理

有时，你可能会遇到无法处理的异常，需要将它们抛给上层调用者。这个时候，你就需要使用 throws 关键字声明异常，将异常交给方法的调用者来处理。

// 抛出异常
public void readFile(String filename) throws IOException {
    FileReader reader = new FileReader(filename);
}

// 捕获异常
try {
    readFile("不存在的文件.txt");
} catch (IOException e) {
    System.out.println("文件读取失败！");
}

3. finally：资源清理，异常处理的“保险”

finally 块中的代码无论是否发生异常都会执行，通常用于清理资源，比如关闭文件、数据库连接等。无论是否有异常，finally 都会执行，确保资源不被泄露。

try {
    FileReader reader = new FileReader("file.txt");
    // 处理文件
} catch (IOException e) {
    System.out.println("文件读取失败！");
} finally {
    System.out.println("无论如何都要关闭文件流！");
}

代码解析：

我提供的代码展示了如何使用 try-catch-finally 语句来处理文件读取操作，并确保无论是否发生异常，都能执行一些清理操作（例如关闭文件流）。

try 块：

try {
    FileReader reader = new FileReader("file.txt");
    // 处理文件
}

在 try 块中，我们尝试创建一个 FileReader 实例并读取名为 "file.txt" 的文件。
如果文件 "file.txt" 存在并且可访问，FileReader 将正常打开文件进行处理。
如果文件不存在，或者文件路径无效，或者文件权限不足，将抛出 IOException 异常。

catch 块：

catch (IOException e) {
    System.out.println("文件读取失败！");
}

如果在 try 块中发生了 IOException 异常（如文件未找到、无法读取文件等），catch 块会捕获该异常并执行其中的代码。
这里，异常消息 "文件读取失败！" 将被打印到控制台。
你可以在 catch 块中执行任何处理，如日志记录、错误处理或清理操作。

finally 块：

finally {
    System.out.println("无论如何都要关闭文件流！");
}

finally 块中的代码无论 try 块中是否抛出异常都会执行。通常，这个块用于清理资源，例如关闭文件流、数据库连接、网络连接等。
在你的代码中，虽然没有显式关闭文件流，但是 finally 块打印了一条信息，表示资源清理的必要性。
如果在 try 中打开了文件流，应该在 finally 块中关闭文件流，以防止资源泄漏。

改进代码：确保文件流被关闭

在文件操作中，资源（如文件流）应该在使用完后关闭，否则可能会导致资源泄漏。下面的代码展示了如何确保无论是否发生异常，都能关闭 FileReader。

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            reader = new FileReader("file.txt");
            // 处理文件
            System.out.println("文件读取成功！");
        } catch (IOException e) {
            System.out.println("文件读取失败！");
        } finally {
            // 确保文件流被关闭
            try {
                if (reader != null) {
                    reader.close();  // 关闭文件流
                    System.out.println("文件流已关闭！");
                }
            } catch (IOException e) {
                System.out.println("关闭文件流时出错！");
            }
        }
    }
}

解释：

资源管理：通过 reader = new FileReader("file.txt"); 打开文件流，并通过 reader.close(); 关闭它，确保即使在发生异常时文件流也会被关闭。
多层 try-catch：在 finally 块中，我们使用了一个新的 try-catch 块来捕获在关闭文件流时可能发生的异常。如果文件流无法正常关闭，会抛出 IOException，并在 catch 块中处理。
关闭文件流的必要性：如果你没有在 finally 中关闭文件流，可能会导致文件流未关闭，从而消耗系统资源，甚至在程序结束时没有释放相关文件资源。关闭文件流是资源管理的关键部分。

小结：

try-catch-finally 是处理文件读取和资源管理的基本结构，能够确保资源被正确释放，即使在发生异常时。
finally 块 用于执行清理操作，它确保即使发生异常，清理代码仍会被执行。在文件读取操作中，finally 块常常用于关闭文件流。

总结：异常处理是提高程序稳定性的关键 🔑

通过理解 Java 的异常类体系和常见的异常处理机制，你可以有效地提升程序的健壮性和稳定性。在面对意外事件时，合理的异常处理不仅能避免程序崩溃，还能让程序优雅地恢复，甚至给用户提供有价值的反馈。所以，不要害怕异常，学会利用它们，让你的代码在“风雨”中依旧保持稳定！

🧧福利赠与你🧧

无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学SpringBoot」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门SpringBoot，就像滚雪球一样，越滚越大，无边无际，指数级提升。

最后，如果这篇文章对你有所帮助，帮忙给作者来个一键三连，关注、点赞、收藏，您的支持就是我坚持写作最大的动力。

同时欢迎大家关注公众号:「猿圈奇妙屋」，以便学习更多同类型的技术文章，免费白嫖最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板、技术文章Markdown文档等海量资料。

✨️ Who am I?

我是bug菌，CSDN | 掘金 | InfoQ | 51CTO | 华为云 | 阿里云 | 腾讯云等社区博客专家，C站博客之星Top30，华为云2023年度十佳博主，掘金多年度人气作者Top40，掘金等各大社区平台签约作者，51CTO年度博主Top12，掘金/InfoQ/51CTO等社区优质创作者；全网粉丝合计 30w+；更多精彩福利点击这里；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试真题、4000G PDF电子书籍、简历模板等海量资料，你想要的我都有，关键是你不来拿。

-End-

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

💥 深入探索 Java 异常类：让你编程不再“崩溃”！ 🚀

前言：异常背后的“危机”和“机会” 💡

异常类的体系：从错误到异常，层次分明 🧐

1. Error 类：无法抗拒的“天灾”

2. Exception 类：程序中的“意外”

2.1 检查型异常（Checked Exception）

2.2 非检查型异常（Unchecked Exception）

3. 自定义异常：你也可以成为“异常制造者”

异常处理：如何优雅地“捕获”程序中的意外 👀

1. try-catch：捕获异常，避免程序崩溃

2. throws：将异常“甩”给调用者处理

3. finally：资源清理，异常处理的“保险”

总结：异常处理是提高程序稳定性的关键 🔑

🧧福利赠与你🧧

✨️ Who am I?

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

💥 深入探索 Java 异常类：让你编程不再“崩溃”！ 🚀

前言：异常背后的“危机”和“机会” 💡

异常类的体系：从错误到异常，层次分明 🧐

1. Error 类：无法抗拒的“天灾”

2. Exception 类：程序中的“意外”

2.1 检查型异常（Checked Exception）

2.2 非检查型异常（Unchecked Exception）

3. 自定义异常：你也可以成为“异常制造者”

异常处理：如何优雅地“捕获”程序中的意外 👀

1. try-catch：捕获异常，避免程序崩溃

2. throws：将异常“甩”给调用者处理

3. finally：资源清理，异常处理的“保险”

总结：异常处理是提高程序稳定性的关键 🔑

🧧福利赠与你🧧

✨️ Who am I?

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品