Java 异常处理其实很简单，看完你就懂！-优快云博客

本文链接：https://blog.youkuaiyun.com/GAL555/article/details/140686571

大家好呀，我是小欧！
今天我们来聊聊Java中的异常处理。很多新手一听到“异常处理”这四个字就开始头大，其实它真的没那么难。咱们从头开始，一步步来，你肯定能搞懂！

什么是异常？

先来解释一下什么是异常。简单说，异常就是程序运行时遇到的一些“意外情况”，比如让程序去读取一个不存在的文件，或者让程序去做除零运算，都会报错。

Java里的异常分为两类：检查型异常（Checked Exceptions）和非检查型异常（Unchecked Exceptions）。

检查型异常：必须在代码里处理，不然编译器会不开心，比如IOException。
非检查型异常：也叫运行时异常（Runtime Exception），可以处理也可以不处理，比如NullPointerException。

异常类的继承关系

在深入了解异常处理之前，咱们先来看看Java异常类的继承关系。所有的异常类都是从 Throwable 类派生出来的。Throwable 有两个重要的子类：Error 和 Exception。

Error：表示严重的系统错误，程序一般无法恢复，也不应该捕获。比如 OutOfMemoryError。
Exception：表示程序正常运行时可以预料的异常情况，分为检查型异常和非检查型异常。

Exception 又分为两类：

检查型异常：必须处理的异常，比如 IOException。
非检查型异常：也叫运行时异常，通常是编程错误，比如 NullPointerException。

下图展示了异常类的基本继承关系：

          Throwable
         /          \
      Error       Exception
                    /     \
         RuntimeException  OtherExceptions

异常处理的基本结构

在Java里，异常处理主要靠 try-catch 语句。结构如下：

try {
    // 可能会出问题的代码
} catch (异常类型1 变量名1) {
    // 处理异常的代码
} catch (异常类型2 变量名2) {
    // 处理异常的代码
} finally {
    // 一定会执行的代码
}

Try Block

try 块中放置可能会抛出异常的代码。如果没有异常发生，try 块里的代码会正常执行。如果发生异常，程序会跳到相应的 catch 块。

Catch Block

catch 块用于捕获和处理异常。你可以有多个 catch 块，每个块处理不同类型的异常。如果 try 块中发生了异常，程序会跳到第一个匹配的 catch 块。

Finally Block

finally 块中的代码无论是否发生异常都会执行，通常用于释放资源，比如关闭文件或数据库连接。

多重捕获和嵌套异常

有时候一个 try 块中可能会抛出多种异常，这时候我们可以使用多重 catch 块。

try {
    // 可能抛出多种异常的代码
} catch (IOException e) {
    // 处理IOException
} catch (SQLException e) {
    // 处理SQLException
}

另外，异常处理块可以嵌套使用，也就是说在一个 catch 块或 finally 块中再嵌套 try-catch 语句。

代码示例：除以零异常

咱们先来看个简单的例子，演示一下如何处理除以零的异常。

public class ExceptionDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        
        try {
            int result = a / b;
            System.out.println("结果是：" + result);
        } catch (ArithmeticException e) {
            System.out.println("哎呀，除数不能为零！");
        } finally {
            System.out.println("这个代码无论如何都会执行。");
        }
    }
}

运行结果：

哎呀，除数不能为零！
这个代码无论如何都会执行。

在这个例子中，a / b 会产生一个 ArithmeticException，所以程序跳到 catch 块，输出“哎呀，除数不能为零！”。无论是否发生异常，finally 块中的代码都会执行。

代码示例：文件读取异常

再来看个稍微复杂点的例子——读取文件内容。我们用 FileReader 和 BufferedReader 来读取文件，过程中可能会发生 FileNotFoundException 和 IOException。

import java.io.*;

public class FileReadDemo {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            File file = new File("example.txt");
            reader = new BufferedReader(new FileReader(file));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("哎呀，文件找不到了！");
        } catch (IOException e) {
            System.out.println("哎呀，读取文件出错了！");
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                System.out.println("哎呀，关闭文件时出错了！");
            }
        }
    }
}

运行结果：

如果 example.txt 文件存在并且内容如下：

Hello, World!
Java Exception Handling is easy!

输出结果为：

Hello, World!
Java Exception Handling is easy!
这个代码无论如何都会执行。

如果文件不存在：

哎呀，文件找不到了！
这个代码无论如何都会执行。

异常链

异常链是指一个异常引发另一个异常。Java中你可以使用 Throwable 类的 initCause 方法来关联异常。

public class ExceptionChainDemo {
    public static void main(String[] args) {
        try {
            method1();
        } catch (Exception e) {
            System.out.println("Caught exception: " + e);
            System.out.println("Caused by: " + e.getCause());
        }
    }

    public static void method1() throws Exception {
        try {
            method2();
        } catch (Exception e) {
            throw new Exception("Exception in method1", e);
        }
    }

    public static void method2() throws Exception {
        throw new Exception("Exception in method2");
    }
}

运行结果：

Caught exception: java.lang.Exception: Exception in method1
Caused by: java.lang.Exception: Exception in method2

这里，method2 抛出的异常被 method1 捕获，然后 method1 抛出一个新的异常，并将原始异常作为原因。这就是异常链的机制。

自定义异常

有时候，我们需要自定义一些异常来处理特定情况。自定义异常非常简单，只需继承 Exception 类或其子类即可。

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

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomException e) {
            System.out.println("哎呀，" + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomException {
        if (age < 18) {
            throw new CustomException("年龄必须大于或等于18岁");
        } else {
            System.out.println("年龄合法");
        }
    }
}

运行结果：

哎呀，年龄必须大于或等于18岁

在这个例子中，我们定义了一个 CustomException，并在 validateAge 方法中根据条件抛出这个异常。这样就可以通过自定义异常来处理特定的业务逻辑了。

异常处理的最佳实践

最后，分享一些异常处理的最佳实践：

优雅地处理异常：尽量不要使用空的 catch 块。至少记录一下异常日志。
不要滥用异常：异常是用来处理意外情况的，不要用它们来控制程序流。
使用自定义异常：如果有特定的业务需求，使用自定义异常可以提高代码的可读性和可维护性。
释放资源：使用 finally 块或Java 7引入的 try-with-resources 语句来确保资源被正确释放。

try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.out.println("哎呀，读取文件出错了！");
}

通过这种方式，reader 会在使用完毕后自动关闭，无需手动处理。

总结

异常处理是Java编程中非常重要的一部分。通过 try-catch 结构，我们可以优雅地捕获和处理程序运行中的各种异常，确保程序的健壮性。无论是基础的除零异常，还是文件读取异常，甚至是自定义异常，掌握这些技能后，你就能够更加从容地面对Java编程中的各种“意外情况”了。
希望这篇文章能帮你搞懂Java的异常处理。如果你还有什么疑问或者想了解更多内容，关注+订阅欢迎留言讨论！