0. 异常的基本概念

异常（Exception）是指在程序运行过程中发生的错误事件。Throwable 类是 Java 中所有错误和异常的根类，它位于 java.lang 包下。所有 Java 异常和错误都继承自 Throwable 类。

Throwable 类有两个主要的子类：

1. Error：表示系统级别的错误，一般由 Java 虚拟机抛出，程序通常不能通过异常处理机制捕获和恢复这些错误。
2. Exception：表示程序中可以被捕获并处理的异常。程序员可以通过异常处理机制（try-catch）来捕获并处理这些异常。

Throwable 类层次结构：

• Throwable: 所有错误和异常的超类。
  • Error: 通常表示系统层面的问题，程序不能通过捕获来恢复。
    • 如：OutOfMemoryError, StackOverflowError 等。
  • Exception: 可以被程序捕获和处理的异常。
    • Checked Exception: 必须被显式地处理，编译时会检查的异常。
      • 如：IOException, SQLException 等。
    • Unchecked Exception: 不强制要求捕获和处理，继承自 RuntimeException。
      • 如：NullPointerException, ArrayIndexOutOfBoundsException 等。

在 Java 中，异常（Exception）可以分为 检查异常（Checked Exception） 和 运行时异常（Unchecked Exception） 两种类型。这两种异常类型的区别主要体现在程序员是否需要显式地处理异常以及它们的使用场景。

1. 检查异常和运行时异常

1. Checked Exception（检查异常）

定义：检查异常是指在编译时由 Java 编译器检查出来的异常。程序必须在代码中显式地处理这些异常（使用 try-catch 块）或通过 throws 声明抛出异常。

特点：

• 必须处理：编译器要求程序员在方法中处理这些异常。
• 程序员可以选择在 try-catch 块中捕获这些异常，或者将它们传递给调用者（通过 throws 声明）。
• 通常用于那些可以预见到的、外部环境引起的异常，例如文件操作、网络连接等。

常见的检查异常：

• IOException：表示输入/输出操作失败或中断。
• SQLException：表示数据库访问错误。
• FileNotFoundException：表示文件未找到。
• ClassNotFoundException：表示类加载失败。
• ParseException：表示解析错误（如日期格式解析错误）。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import java.io.*;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            // 需要处理或声明抛出的检查异常
            FileReader file = new FileReader("nonexistentfile.txt");
            BufferedReader reader = new BufferedReader(file);
            System.out.println(reader.readLine());
        } catch (IOException e) {
            // 捕获并处理异常
            System.out.println("捕获到 IOException: " + e.getMessage());
        }
    }
}

在上述代码中，FileReader 和 BufferedReader 的使用可能会抛出 IOException，因此必须使用 try-catch 块来捕获和处理这个异常。如果没有处理该异常，程序将无法编译通过。

编译时检查：
如果你没有捕获检查异常，也没有在方法声明中使用 throws 关键字声明抛出该异常，编译器将报错，提示你必须显式地处理或声明抛出异常。

2. Unchecked Exception（运行时异常）

定义：运行时异常是指那些在程序运行时可能发生的异常。与检查异常不同，运行时异常是由程序的逻辑错误或不当操作引起的，通常不需要强制要求处理。

特点：

• 不需要强制处理：程序员可以选择不处理这些异常。
• 通常表示程序错误：运行时异常多发生于逻辑错误或不正确的程序操作，例如空指针引用、数组越界等。
• 继承自 RuntimeException 类，RuntimeException 本身是 Exception 的子类。

常见的运行时异常：

• NullPointerException：当程序尝试访问空对象时抛出。
• ArrayIndexOutOfBoundsException：当数组访问越界时抛出。
• ArithmeticException：算术运算异常，如除以零。
• ClassCastException：类型转换异常，通常是对象类型不兼容。
• IllegalArgumentException：方法传递了非法参数时抛出。

示例：

1
2
3
4
5
6
7
8
9
10
11
12

public class UncheckedExceptionExample {
    public static void main(String[] args) {
        int[] arr = new int[3];
        
        // 访问数组的越界元素，将抛出 ArrayIndexOutOfBoundsException
        try {
            System.out.println(arr[5]);  // 数组索引越界
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到 ArrayIndexOutOfBoundsException: " + e.getMessage());
        }
    }
}

在上述代码中，访问数组的越界元素会抛出 ArrayIndexOutOfBoundsException，这是一种运行时异常。虽然可以选择捕获它，但程序并不要求必须捕获运行时异常，程序可以继续执行。

编译时不检查：
与检查异常不同，编译器并不会强制要求程序员处理运行时异常。程序员可以选择捕获这些异常，也可以选择不捕获它们，这取决于具体的业务需求。

3. 区别总结

4. 何时使用检查异常和运行时异常

• 检查异常：通常用于可恢复的异常情况，如文件读取、网络连接等。遇到这类问题时，程序可以采取某些措施来恢复或向用户报告错误。

  • 例如：当操作文件时，IOException 可以被捕获并处理，程序可以尝试重新打开文件或提示用户检查文件路径。

• 运行时异常：通常用于不可恢复的错误，程序应该通过更好的逻辑设计来避免这些错误。例如，NullPointerException 应该通过在使用对象之前先检查是否为 null 来避免。

2. 异常处理的语法

Java 提供了 try、catch、finally、throw 和 throws 关键字来处理异常。

2.1 try-catch 语句

try 块用于包围可能抛出异常的代码，catch 块用于捕获异常。

1
2
3
4
5
6
7

try {
    // 可能会抛出异常的代码
    int result = 10 / 0;  // 可能抛出 ArithmeticException
} catch (ArithmeticException e) {
    // 捕获异常并处理
    System.out.println("捕获到异常: " + e.getMessage());
}

2.2 多个 catch 块

你可以使用多个 catch 块来处理不同类型的异常。

1
2
3
4
5
6
7
8
9
10

try {
    int[] arr = new int[3];
    arr[5] = 10;  // 可能抛出 ArrayIndexOutOfBoundsException
} catch (ArithmeticException e) {
    System.out.println("捕获到算术异常");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("捕获到数组索引越界异常");
} catch (Exception e) {
    System.out.println("捕获到其他异常");
}

2.3 finally 块

无论是否发生异常，finally 块中的代码都会执行，通常用于资源清理（如关闭文件流、数据库连接等）。

1
2
3
4
5
6
7

try {
    System.out.println("执行某些操作");
} catch (Exception e) {
    System.out.println("捕获异常");
} finally {
    System.out.println("无论如何都会执行的代码");
}

2.4 throw 关键字

使用 throw 关键字可以抛出一个自定义的异常。通常用于自定义业务逻辑中的异常抛出。

1
2
3
4
5
6
7
8
9

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            throw new Exception("这是一个自定义的异常");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

2.5 throws 关键字

throws 关键字用于声明一个方法可能抛出的异常。方法声明时使用。

1
2
3
4
5
6
7
8
9

public class ThrowsExample {
    public static void main(String[] args) throws Exception {
        throwException();
    }

    public static void throwException() throws Exception {
        throw new Exception("抛出异常");
    }
}

3. 自定义异常

你可以自定义异常类，继承 Exception 或 RuntimeException。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

public class CustomExceptionTest {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("这是一个自定义异常");
        } catch (MyCustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

4. 异常的最佳实践

• 尽量使用具体的异常类：避免使用 Exception 类，应该尽量使用具体的异常类，如 IOException、SQLException 等。
• 避免空捕获（Empty catch block）：不要在 catch 块中什么都不做，至少要记录日志或打印异常信息。
• 捕获特定异常：只捕获程序能够处理的异常类型，避免捕获所有的异常类型。
• 资源管理：使用 try-with-resources 语法来自动关闭资源。

示例：try-with-resources

1
2
3
4
5
6

try (FileReader reader = new FileReader("file.txt")) {
    // 使用 reader 读取文件
} catch (IOException e) {
    System.out.println("文件读取错误");
}
// 不需要显式关闭 reader，自动关闭

5. 总结

• 使用 try、catch 来捕获和处理异常。
• 使用 finally 来确保资源的释放和清理。
• 可以自定义异常类以实现更有意义的异常处理。
• 通过 throw 和 throws 来抛出和声明异常。

异常处理是提高 Java 程序健壮性的重要手段，合理的异常处理能帮助程序在异常情况下仍能平稳运行，并给出明确的错误信息。