Java异常处理详解#

什么是异常？#

异常是程序运行过程中发生的意外情况，它会中断程序的正常执行流程。在Java中，异常是一个对象，它表示程序运行时发生的错误。

异常的分类#

Java中的异常可以分为两大类：

1. 受检异常（Checked Exceptions）#

受检异常是编译器要求必须处理的异常，它们继承自Exception类（除了RuntimeException及其子类）。

常见的受检异常：

IOException：输入输出异常
SQLException：数据库访问异常
ClassNotFoundException：类未找到异常
FileNotFoundException：文件未找到异常

2. 非受检异常（Unchecked Exceptions）#

非受检异常是编译器不要求必须处理的异常，它们继承自RuntimeException类。

常见的非受检异常：

NullPointerException：空指针异常
ArrayIndexOutOfBoundsException：数组索引越界异常
ArithmeticException：算术异常（如除零）
IllegalArgumentException：参数非法异常
ClassCastException：类型转换异常

异常的层次结构#

Java异常的层次结构如下：

1
Throwable
2
├── Error
3
│   ├── VirtualMachineError
4
│   ├── OutOfMemoryError
5
│   └── StackOverflowError
6
└── Exception
7
    ├── RuntimeException
8
    │   ├── NullPointerException
9
    │   ├── ArrayIndexOutOfBoundsException
10
    │   ├── ArithmeticException
11
    │   └── IllegalArgumentException
12
    ├── IOException
13
    ├── SQLException
14
    └── ClassNotFoundException

Throwable：所有异常和错误的父类
Error：表示严重的错误，程序一般无法恢复，如内存溢出
Exception：表示程序可以处理的异常

异常处理机制#

Java的异常处理机制主要包括以下几个关键字：

try：尝试执行可能抛出异常的代码
catch：捕获并处理异常
finally：无论是否发生异常，都会执行的代码块
throw：手动抛出异常
throws：声明方法可能抛出的异常

try-catch语句#

1
try {
2
    // 可能抛出异常的代码
3
    int result = 10 / 0; // 会抛出ArithmeticException
4
} catch (ArithmeticException e) {
5
    // 捕获并处理异常
6
    System.out.println("发生算术异常：" + e.getMessage());
7
}

多个catch语句#

1
try {
2
    // 可能抛出多种异常的代码
3
    String str = null;
4
    System.out.println(str.length()); // 会抛出NullPointerException
5
} catch (NullPointerException e) {
6
    // 捕获空指针异常
7
    System.out.println("发生空指针异常：" + e.getMessage());
8
} catch (Exception e) {
9
    // 捕获其他所有异常
10
    System.out.println("发生异常：" + e.getMessage());
11
}

注意：多个catch语句的顺序很重要，子类异常应该在父类异常之前捕获，否则子类异常永远不会被捕获。

try-catch-finally语句#

1
try {
2
    // 可能抛出异常的代码
3
    int result = 10 / 0;
4
} catch (ArithmeticException e) {
5
    // 捕获并处理异常
6
    System.out.println("发生算术异常：" + e.getMessage());
7
} finally {
8
    // 无论是否发生异常，都会执行的代码
9
    System.out.println("finally块执行");
10
}

finally块的用途：

释放资源，如关闭文件、数据库连接等
清理操作

注意：finally块中的代码总是会执行，即使try或catch块中有return语句。

throw语句#

1
public void checkAge(int age) {
2
    if (age < 0) {
3
        // 手动抛出异常
4
        throw new IllegalArgumentException("年龄不能为负数");
5
    }
6
    System.out.println("年龄是：" + age);
7
}

throws声明#

1
// 声明方法可能抛出的异常
2
public void readFile(String filePath) throws IOException, FileNotFoundException {
3
    // 读取文件的代码
4
    File file = new File(filePath);
5
    FileReader reader = new FileReader(file);
6
    // ...
7
}

自定义异常#

在Java中，我们可以通过继承Exception类或其子类来创建自定义异常。

自定义受检异常#

1
public class CustomException extends Exception {
2
    public CustomException() {
3
        super();
4
    }
5

6
    public CustomException(String message) {
7
        super(message);
8
    }
9

10
    public CustomException(String message, Throwable cause) {
11
        super(message, cause);
12
    }
13

14
    public CustomException(Throwable cause) {
15
        super(cause);
16
    }
17
}

自定义非受检异常#

1
public class CustomRuntimeException extends RuntimeException {
2
    public CustomRuntimeException() {
3
        super();
4
    }
5

6
    public CustomRuntimeException(String message) {
7
        super(message);
8
    }
9

10
    public CustomRuntimeException(String message, Throwable cause) {
11
        super(message, cause);
12
    }
13

14
    public CustomRuntimeException(Throwable cause) {
15
        super(cause);
16
    }
17
}

异常处理的最佳实践#

1. 只捕获你能处理的异常#

不要捕获你不能处理的异常，应该让它向上传播，由更上层的代码来处理。

2. 捕获具体的异常#

尽量捕获具体的异常类型，而不是捕获所有异常（catch (Exception e)）。

3. 不要忽略异常#

不要捕获异常后什么都不做，至少应该记录异常信息。

1
// 不好的做法
2
try {
3
    // 可能抛出异常的代码
4
} catch (Exception e) {
5
    // 什么都不做
6
}
7

8
// 好的做法
9
try {
10
    // 可能抛出异常的代码
11
} catch (Exception e) {
12
    // 记录异常信息
13
    System.err.println("发生异常：" + e.getMessage());
14
    e.printStackTrace();
15
}

4. 使用finally块释放资源#

对于需要释放的资源，如文件、数据库连接等，应该在finally块中释放。

1
FileReader reader = null;
2
try {
3
    reader = new FileReader("file.txt");
4
    // 读取文件
5
} catch (FileNotFoundException e) {
6
    System.err.println("文件未找到：" + e.getMessage());
7
} finally {
8
    // 释放资源
9
    if (reader != null) {
10
        try {
11
            reader.close();
12
        } catch (IOException e) {
13
            System.err.println("关闭文件失败：" + e.getMessage());
14
        }
15
    }
16
}

5. 使用try-with-resources语句（Java 7+）#

对于实现了AutoCloseable接口的资源，可以使用try-with-resources语句，它会自动关闭资源。

1
// try-with-resources语句
2
try (FileReader reader = new FileReader("file.txt")) {
3
    // 读取文件
4
} catch (IOException e) {
5
    System.err.println("发生IO异常：" + e.getMessage());
6
}
7
// reader会自动关闭

6. 抛出有意义的异常信息#

抛出异常时，应该提供有意义的异常信息，以便于调试和处理。

1
// 不好的做法
2
if (age < 0) {
3
    throw new IllegalArgumentException();
4
}
5

6
// 好的做法
7
if (age < 0) {
8
    throw new IllegalArgumentException("年龄不能为负数，当前值：" + age);
9
}

7. 区分受检异常和非受检异常#

对于程序可以恢复的错误，使用受检异常
对于程序逻辑错误，使用非受检异常

8. 不要在finally块中使用return语句#

在finally块中使用return语句会覆盖try或catch块中的return语句，导致意外的结果。

1
// 不好的做法
2
public int test() {
3
    try {
4
        return 1;
5
    } finally {
6
        return 2; // 会覆盖try块中的return语句
7
    }
8
}
9
// 调用test()会返回2，而不是1

9. 使用异常链#

当你捕获一个异常并抛出另一个异常时，应该使用异常链，保留原始异常的信息。

1
try {
2
    // 可能抛出异常的代码
3
} catch (SQLException e) {
4
    // 使用异常链
5
    throw new CustomException("数据库操作失败", e);
6
}

10. 记录异常#

在生产环境中，应该使用日志框架记录异常，而不是直接打印到控制台。

1
import org.slf4j.Logger;
2
import org.slf4j.LoggerFactory;
3

4
public class Example {
5
    private static final Logger logger = LoggerFactory.getLogger(Example.class);
6

7
    public void doSomething() {
8
        try {
9
            // 可能抛出异常的代码
10
        } catch (Exception e) {
11
            // 记录异常
12
            logger.error("发生异常", e);
13
        }
14
    }
15
}

常见的异常处理陷阱#

1. 过度使用异常#

不要将异常用于控制流程，异常应该用于处理真正的错误情况。

1
// 不好的做法
2
public int getElement(int[] array, int index) {
3
    try {
4
        return array[index];
5
    } catch (ArrayIndexOutOfBoundsException e) {
6
        return -1;
7
    }
8
}
9

10
// 好的做法
11
public int getElement(int[] array, int index) {
12
    if (index < 0 || index >= array.length) {
13
        return -1;
14
    }
15
    return array[index];
16
}

2. 捕获所有异常#

不要捕获所有异常，这会掩盖真正的错误。

1
// 不好的做法
2
try {
3
    // 可能抛出多种异常的代码
4
} catch (Exception e) {
5
    System.err.println("发生异常：" + e.getMessage());
6
}
7

8
// 好的做法
9
try {
10
    // 可能抛出多种异常的代码
11
} catch (NullPointerException e) {
12
    System.err.println("空指针异常：" + e.getMessage());
13
} catch (ArrayIndexOutOfBoundsException e) {
14
    System.err.println("数组索引越界异常：" + e.getMessage());
15
} catch (Exception e) {
16
    System.err.println("其他异常：" + e.getMessage());
17
}

3. 忽略异常#