Java-异常

前言

Java 的异常机制是 Java 编程语言中用于处理程序执行过程中可能出现的错误或异常情况的一种强大工具。它通过提供一种结构化的方式来捕获和处理异常，从而提高代码的健壮性和可靠性。

异常的基本概念

异常是指在程序运行过程中出现的错误，导致程序无法正常执行。例如，数组访问越界、空指针引用、文件未找到等情况都可能引发异常。Java 使用异常机制来处理这些问题，而不是让程序直接崩溃。

异常本质上是一个对象，所有的异常类都继承自 java.lang.Throwable 类，Throwable 主要有两个直接子类：

Error（错误）：表示严重错误，如 OutOfMemoryError、StackOverflowError 等，通常不应该被程序捕获和处理。
Exception（异常）：表示程序可以处理的异常情况，如 NullPointerException、IOException 等。

异常的分类

Java异常分为两类：

检查型异常（Checked Exception）：

继承自 Exception，但不包括 RuntimeException 及其子类。
需要在编译期处理（必须使用 try-catch 捕获或 throws 声明）。
必须显式处理（捕获或抛出），否则编译失败。
通常是外部错误，如 IOException、SQLException。

非检查型异常（Unchecked Exception）：

包括 RuntimeException 及其子类（如 NullPointerException）和 Error（如 OutOfMemoryError）。
无需强制处理，多由程序逻辑错误导致。

异常层次结构

Java 的异常类是一个树形结构，根类是 Throwable，主要分支如下：

Throwable
├── Error
│   ├── VirtualMachineError
│   │   ├── OutOfMemoryError
│   │   └── StackOverflowError
│   └── LinkageError
└── Exception
    ├── IOException
    ├── SQLException
    └── RuntimeException
        ├── NullPointerException
        ├── ArrayIndexOutOfBoundsException
        └── ArithmeticException

Error 和 Exception 是并列的。
RuntimeException 是运行时异常的基类，通常由编程错误引起。

异常处理机制

Java 的异常机制主要围绕以下几个关键字展开：

try：定义一个可能抛出异常的代码块。
catch：捕获并处理特定类型的异常。
finally：定义无论是否发生异常都必须执行的代码块（例如释放资源）。
throw：手动抛出一个异常。
throws：在方法声明中指定可能抛出的异常，交给调用者处理。

示例代码：

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 可能抛出异常
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            System.out.println("无论如何都会执行 finally 块");
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("除数不能为零"); // 手动抛出异常
        }
        return a / b;
    }
}

运行结果：

1 2	捕获到异常: 除数不能为零无论如何都会执行 finally 块

异常的处理流程

异常的抛出：

当程序执行到某一行代码发生错误时，JVM 会创建一个对应的异常对象，并将其“抛出”。
也可以通过 throw 关键字手动抛出异常。

异常的捕获：

使用 try-catch 块捕获异常。如果 try 块中的代码抛出异常，程序会立即跳转到对应的 catch 块。
catch 块可以指定捕获的异常类型，必须与抛出的异常类型匹配或为其父类。

异常的传播：

如果当前方法没有处理异常（没有 catch 块或 catch 块未捕获该异常），异常会沿着调用栈向上传递，直到被捕获或导致程序终止。

finally 块：

无论 try 块是否抛出异常，finally 块中的代码都会执行。
常用于释放资源（如关闭文件或数据库连接）。

自定义异常

Java 允许开发者通过继承 Exception 或 RuntimeException 创建自定义异常类。

示例：

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

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (MyException e) {
            System.out.println("异常: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws MyException {
        if (age < 18) {
            throw new MyException("年龄必须大于18岁");
        }
        System.out.println("年龄验证通过");
    }
}

运行结果：

1	异常: 年龄必须大于18岁

异常处理的最佳实践

具体捕获异常：

尽量捕获具体的异常类型，而不是直接用 Exception 捕获所有异常，以便针对性地处理。

try {
    // 代码
} catch (NullPointerException e) {
    // 处理空指针
} catch (IOException e) {
    // 处理IO异常
}

不要在 catch 语句中忽略异常：

捕获异常后至少记录日志，而不是简单地忽略。

try {
    // 代码
} catch (IOException e) {
    // 什么都不做（不推荐）
}

使用 finally 释放资源：

对于文件、数据库连接等资源，确保在 finally 中关闭。

合理使用 throws：

如果方法无法处理异常，可以通过 throws 将其抛给调用者。

尽量避免运行时异常：

通过防御性编程（如检查 null 值或数组边界）减少 RuntimeException 的发生。

抛出有意义的异常:

不要使用 throw new Exception("错误")，而是使用更具体的异常，如：

1	throw new IllegalArgumentException("参数不能为负数");

日志记录：

将异常信息记录到日志中，而不是单纯地打印异常。

Java 7+ 的改进

多重捕获（Multi-catch）： Java 7 引入了用 | 分隔多个异常类型的能力，减少代码冗余。

try {
    // 代码
} catch (IOException | SQLException e) {
    e.printStackTrace();
}

try-with-resources：自动管理资源的关闭，无需显式使用 finally。

try (FileInputStream fis = new FileInputStream("file.txt")) {
    // 使用 fis
} catch (IOException e) {
    e.printStackTrace();
}

后记

异常类型	继承自	是否必须处理	示例
`Error`	`Throwable`	否	`OutOfMemoryError`
`Exception`	`Throwable`	是（除非是 `RuntimeException` 子类）	`IOException`
`RuntimeException`	`Exception`	否	`NullPointerException`

Java 的异常机制通过 try-catch-finally 和 throws 提供了强大的错误处理能力。合理使用异常处理可以提高代码的健壮性和可维护性。