【Java】Java中的异常

---

一、什么是异常

1.1 异常的概念

在Java中，异常（Exception）是指程序执行过程中可能出现的不正常情况或错误。它是一个事件，它会干扰程序的正常执行流程，并可能导致程序出现错误或崩溃。

异常在Java中是以对象的形式表示的，这些对象是从java.lang.Throwable类或其子类派生而来。Throwable是异常类层次结构的根类，它有两个主要的子类：java.lang.Exception和java.lang.Error。

1. Exception（异常）：java.lang.Exception是表示可检查异常的基类。可检查异常是指在编译时需要显式处理的异常。Exception类及其子类用于表示程序运行过程中可能出现的外部条件、错误或其他可恢复的情况。例如，文件未找到、网络连接中断、输入格式错误等。开发人员需要通过捕获或声明这些异常来确保在程序中进行适当的异常处理。

2. Error（错误）：java.lang.Error是表示严重问题或系统级错误的基类。错误是指那些程序通常无法处理或恢复的情况，例如内存溢出、堆栈溢出、虚拟机错误等。与异常不同，错误不需要在程序中显式处理，因为它们通常表示了无法解决的问题。

异常在Java中通过抛出（throw）和捕获（catch）的方式进行处理。当程序执行到可能引发异常的代码时，可以使用throw语句手动抛出异常对象。然后，可以使用try-catch语句块来捕获异常，并在catch块中提供相应的异常处理逻辑。在catch块中，可以根据异常的类型执行适当的操作，如日志记录、错误报告或异常处理。如果异常没有在当前方法中被捕获处理，它将继续向上级调用栈传播，直到找到合适的异常处理代码或导致程序终止。

1.2 异常的分类

在Java中，异常可以按照其类型进行分类。下面是Java中异常的主要分类：

1. 可检查异常（Checked Exceptions）：可检查异常是指在编译时会被检查的异常，程序必须显式地处理它们，否则编译器会报错。可检查异常通常表示程序在运行过程中可能出现的外部条件或错误。例如，文件不存在、网络连接问题等。可检查异常是Exception类（及其子类）的实例。

2. 运行时异常（Runtime Exceptions）：运行时异常也被称为非检查异常（Unchecked Exceptions）。这些异常在编译时不会被强制检查，而是在程序运行时才会抛出。运行时异常通常表示程序内部的错误或逻辑错误，例如，空指针引用、除以零等。运行时异常是RuntimeException类（及其子类）的实例。

3. 错误（Errors）：错误表示Java虚拟机（JVM）本身出现的严重问题，通常无法恢复或处理。错误可能是内存溢出、堆栈溢出等严重问题。与异常不同，错误一般不应该被捕获和处理，因为它们指示了无法解决的问题。错误是Error类（及其子类）的实例。

这些异常类型的区别在于编译器对它们的检查方式以及程序员对它们的处理要求。可检查异常在编译时要求显式处理，要么通过try-catch块捕获并处理，要么通过在方法签名中声明该异常并由调用者处理。运行时异常可以选择捕获和处理，但不是强制要求。而错误通常不应该被捕获和处理。

二、异常的体系结构

在Java中，异常类的体系结构是通过继承关系组织的。以下是Java异常类的体系结构图及其说明：

• Throwable是异常类体系结构的根类。它是所有异常类的超类，直接或间接地派生了Error和Exception两个主要子类。

• Error表示严重的问题或系统级错误，它们通常是由Java虚拟机（JVM）本身引起的，例如内存溢出、堆栈溢出等。程序通常无法恢复或处理这些错误。

• Exception是表示可检查异常的基类。它包括两个主要的分支：

  • RuntimeException是运行时异常的基类，它表示程序内部错误或逻辑错误。这些异常通常是由编程错误引起的，例如空指针引用、除以零等。运行时异常在编译时不会被强制检查，因此可以选择捕获和处理它们，但也可以选择不处理。

  • Exception的其他子类表示其他可检查异常，例如输入/输出异常（IOException）、SQL异常（SQLException）等。这些异常在编译时会被强制检查，程序必须显式地处理它们，否则会导致编译错误。

Java异常类体系结构的组织方式使得开发人员可以根据异常的类型和性质来选择适当的异常类来表示和处理不同类型的异常情况。这种结构使得异常处理更加灵活和可扩展，并且提供了一致的异常处理机制。

三、异常的处理

3.1 异常的抛出

在Java中，异常的抛出是通过使用throw关键字来实现的。throw关键字用于抛出一个异常对象，将异常传递给调用者或上层调用栈。

以下是异常的抛出示例：

public class Example {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 调用自定义方法
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("发生了算术异常：" + e.getMessage());
        }
    }
    
    public static int divide(int num1, int num2) {
        if (num2 == 0) {
            throw new ArithmeticException("除数不能为零"); // 抛出算术异常
        }
        return num1 / num2;
    }
}

在上面的示例中，divide()方法用于计算两个数的除法操作。如果除数为零，将会抛出一个算术异常（ArithmeticException）。在main()方法中，我们调用了divide()方法，并使用try-catch块来捕获可能抛出的异常。如果捕获到算术异常，将会输出相应的错误信息。

另外，除了手动抛出异常，Java还提供了许多内置的异常类，例如NullPointerException、ArrayIndexOutOfBoundsException等。这些异常类可以在特定情况下自动抛出，无需显式使用throw关键字。

以下是一个示例，演示了数组越界异常的自动抛出：

public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        
        try {
            int value = arr[5]; // 数组越界，将抛出ArrayIndexOutOfBoundsException异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("发生了数组越界异常：" + e.getMessage());
        }
    }
}

在上面的示例中，我们尝试访问数组中索引为5的元素，而实际数组只有3个元素，因此会抛出一个数组越界异常（ArrayIndexOutOfBoundsException）。通过try-catch块捕获该异常，并输出错误信息。

异常的抛出和捕获机制使得程序能够在出现异常情况时进行适当的处理，避免程序崩溃或产生不可预测的结果。通过合理地抛出和处理异常，可以增加程序的可靠性和健壮性。

3.2 异常的捕获与处理

1. 异常声明throws

在Java中，使用throws关键字可以在方法声明中指定该方法可能抛出的异常类型。通过使用throws关键字，方法可以将异常的处理责任委托给调用者，而不是在方法内部处理异常。

以下是异常声明throws的示例：

public class Example {
    public static void main(String[] args) {
        try {
            readFile("file.txt"); // 调用自定义方法
        } catch (FileNotFoundException e) {
            System.out.println("文件未找到：" + e.getMessage());
        }
    }
    
    public static void readFile(String filename) throws FileNotFoundException {
        // 尝试打开文件
        // 如果文件不存在，将抛出FileNotFoundException异常
        FileInputStream fis = new FileInputStream(filename);
        // 其他处理逻辑...
    }
}

在上面的示例中，readFile()方法用于读取指定文件的内容。由于打开文件可能出现文件不存在的情况，因此在方法声明中使用了throws FileNotFoundException来指定该方法可能抛出的异常类型。这样，调用者在调用readFile()方法时，必须处理或继续向上抛出该异常。

在main()方法中，我们调用了readFile()方法，并使用try-catch块来捕获可能抛出的FileNotFoundException异常。如果捕获到异常，将会输出相应的错误信息。

需要注意的是，如果一个方法声明了抛出异常，但在方法内部没有实际抛出该异常，编译器会报错。因此，在使用throws关键字声明异常时，需要确保方法内部的代码可能会抛出相应的异常。

通过使用throws关键字声明异常，可以将异常处理的责任从方法内部转移到调用者处，使得代码更加清晰和模块化。同时，它也提供了更大的灵活性，允许在调用链中的合适位置进行异常处理。

2. try-catch捕获并处理

在Java中，可以使用try-catch语句块来捕获和处理异常。try-catch语句块允许我们在执行可能引发异常的代码时，捕获并处理异常，从而防止程序终止或产生不可预测的结果。

以下是try-catch捕获和处理异常的示例：

public class Example {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 调用自定义方法
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("发生了算术异常：" + e.getMessage());
        }
    }
    
    public static int divide(int num1, int num2) {
        try {
            return num1 / num2;
        } catch (ArithmeticException e) {
            throw new ArithmeticException("除数不能为零"); // 抛出算术异常
        }
    }
}

在上面的示例中，divide()方法用于计算两个数的除法操作。在方法内部，我们使用了try-catch语句块来捕获可能发生的算术异常。如果除数为零，将抛出一个算术异常（ArithmeticException）。在main()方法中，我们调用了divide()方法，并使用try-catch块捕获可能抛出的算术异常。如果捕获到异常，将会输出相应的错误信息。

需要注意的是，当异常被捕获时，程序将跳转到匹配的catch块，并执行其中的代码。在catch块中，我们可以根据异常的类型执行相应的操作，例如输出错误信息、记录日志或进行其他处理逻辑。

通过使用try-catch语句块，我们可以在程序中有选择地捕获和处理异常，从而保证程序的正常执行。这种异常处理机制使得代码更加健壮，能够在面对异常情况时进行适当的处理和恢复，避免程序崩溃或产生不可预测的结果。

3. finally代码块

在Java中，finally代码块用于定义无论是否发生异常都会被执行的代码。无论是在异常被捕获和处理后，还是在异常未被捕获时，finally代码块中的代码都会被执行。finally代码块通常用于释放资源或执行必要的清理操作。

下面是使用Scanner的示例，演示了finally代码块的使用：

import java.util.Scanner;

public class Example {
    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            scanner = new Scanner(System.in);
            System.out.print("请输入一个整数: ");
            int num = scanner.nextInt();
            System.out.println("输入的整数是: " + num);
        } catch (Exception e) {
            System.out.println("发生了异常: " + e.getMessage());
        } finally {
            if (scanner != null) {
                scanner.close(); // 释放资源
            }
        }
    }
}

在上面的示例中，我们使用了Scanner类来读取用户的输入整数。在try块中，我们创建了一个Scanner对象并读取用户的输入。如果在输入过程中发生异常，将会被捕获并输出相应的错误信息。

不管是否发生异常，finally代码块中的代码都会执行。在这个示例中，我们在finally块中检查Scanner对象是否为空，如果不为空，则调用close()方法来释放资源。

通过使用finally代码块，我们可以确保无论发生什么情况，资源都能得到正确地释放。这在需要处理资源（如文件、网络连接等）的情况下非常重要，以防止资源泄漏和程序不稳定性。

需要注意的是，finally代码块并不是必需的，可以选择省略。但是，如果使用了finally代码块，它将始终执行，无论是否发生异常。

3.3 异常的处理流程

异常的处理流程可以概括为以下几个步骤：

1. 执行可能引发异常的代码块。这部分代码通常被包裹在try块中。

2. 当在try块中发生异常时，程序会立即跳转到与异常类型匹配的catch块。catch块用于捕获和处理特定类型的异常。

3. 在匹配的catch块中，根据异常的类型执行相应的操作，例如输出错误消息、记录日志或采取其他处理措施。多个catch块可以按照顺序排列，以处理不同类型的异常。

4. 如果没有匹配的catch块或异常在catch块中未被处理，异常将被传递给上一级调用栈，继续寻找异常处理代码。

5. 如果在当前方法中没有合适的异常处理代码，异常将继续向上层调用栈传递，直到找到能够处理异常的地方。

6. 如果在调用栈中找到能够处理异常的catch块，相应的异常处理代码将被执行。

7. 在异常处理完成后，程序将继续执行try-catch结构之后的代码。

8. 如果存在finally代码块，不论异常是否发生，finally中的代码都会被执行。finally代码块通常用于释放资源、进行清理操作或确保一些必要的代码逻辑得以执行。

通过这样的异常处理流程，可以捕获和处理异常，避免程序的意外终止，并进行适当的错误处理。异常处理使得代码具备了更好的健壮性和容错性，可以保证程序在异常情况下的正常运行，并提供相应的错误信息和处理机制。

四、自定义异常类

4.1 自定义异常类的规则

在Java中，可以通过创建自定义异常类来表示和处理特定的异常情况。以下是关于自定义异常类的一些规则：

1. 自定义异常类应继承自Exception类或其子类。通常，如果自定义异常类表示非检查异常，则可以继承RuntimeException类或其子类。

2. 自定义异常类应提供适当的构造方法。通常，至少应包含一个带有异常信息的构造方法，以便在抛出异常时传递详细信息。可以根据需要添加其他构造方法，以便传递更多的异常信息和原因。

3. 自定义异常类可以添加自定义的方法和逻辑，以满足特定需求。例如，可以添加用于获取特定信息的方法或执行特定操作的方法。

4. 自定义异常类的命名应具有描述性，并遵循Java的命名约定。通常，类名以Exception结尾是一种常见的命名约定，例如MyCustomException。

5. 自定义异常类可以根据特定的异常情况进行层次化。您可以创建自定义异常类的层次结构，通过继承关系来表示不同级别或类型的异常。这有助于更好地组织和处理不同类型的异常。

以下是一个示例，展示了一个自定义异常类的规则和示例代码：

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

    public MyCustomException(String message) {
        super(message);
    }

    public MyCustomException(String message, Throwable cause) {
        super(message, cause);
    }

    public MyCustomException(Throwable cause) {
        super(cause);
    }

    // 可以添加自定义的方法和逻辑
}

在上述示例中，创建了一个名为MyCustomException的自定义异常类。该类继承自Exception类，并提供了多个构造方法，以便在抛出异常时传递不同的异常信息和原因。

4.2 自定义异常案例

这里实现一个用户登陆功能，在登录的时候对用户名和密码进行校验，登录和校验的逻辑如下：

public class Login {
    private String userName = "admin";
    private String password = "123456";

    public void loginInfo(String userName, String password) {
        try{
            if (!this.userName.equals(userName)) {

                throw new UserNameErrorException("用户名错误！");
                // System.out.println("用户名错误！");
                // return;
            }
            if (!this.password.equals(password)) {

                throw new PasswordException("密码错误！");
                // System.out.println("密码错误！");
                // return;
            }
            System.out.println("登陆成功");
        } catch (UserNameErrorException | PasswordException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Login login = new Login();
        login.loginInfo("admin", "123456");
    }
}

在上述代码中，Login类包含了一个名为loginInfo的方法，该方法接受用户名和密码作为参数。在方法中，我们使用try-catch块来捕获可能抛出的UserNameErrorException和PasswordException异常。

在try块中，我们检查输入的用户名和密码是否与预定义的用户名和密码匹配。如果不匹配，我们抛出相应的异常，即UserNameErrorException或PasswordException。如果用户名和密码都正确，将输出"登录成功"。

在catch块中，我们捕获并处理可能抛出的异常。通过调用printStackTrace()方法，异常的堆栈跟踪信息将被打印出来，以便进行错误排查和调试。

在main方法中，创建一个Login对象并调用loginInfo方法来进行登录测试。在本例中，我们传递了正确的用户名和密码，因此输出将是"登录成功"。如果用户名或密码错误，将在控制台上打印异常的堆栈跟踪信息。

自定义异常类 PasswordException 和 UserNameErrorException ：

public class PasswordException extends RuntimeException{
    public PasswordException(){
        super();
    }
    public PasswordException(String message){
        super(message);
    }
}

public class UserNameErrorException extends RuntimeException{
    public UserNameErrorException(){
        super();
    }
    public UserNameErrorException(String message){
        super(message);
    }
}

在上述代码中，PasswordException和UserNameErrorException类都继承自RuntimeException类，因此它们都是非检查异常。

这两个异常类提供了两个构造方法：

1. 无参构造方法：调用父类RuntimeException的无参构造方法，用于创建一个没有特定错误信息的异常对象。

2. 带有字符串参数的构造方法：调用父类RuntimeException的带有字符串参数的构造方法，用于创建一个带有特定错误信息的异常对象。

通过定义这两个自定义异常类，可以在需要时抛出PasswordException和UserNameErrorException异常，并传递适当的错误信息。这样可以更好地处理与密码和用户名相关的异常情况，并提供有关错误的详细信息。