【从零开始学习JAVA | 第三十二篇】异常（下）新手必学！

ゝ一世哀愁。 2023-10-14 08:43 48阅读 0赞

![69b6760388dc4298b817e182f61921c0.png][]

**目录**

前言：

Exceptions（异常）：

异常的两大作用：

异常的处理方式：

1.JVM默认处理

2.自己捕获异常

3.抛出处理

自定义异常：

异常的优点：

总结：

--------------------

## 前言： ##

前文我们详细的为大家介绍了整个异常体系的框架，本篇我们将为大家介绍**Exceptions**异常，我们会讲解他的作用以及如何捕获，**这一篇很重要！！在搭建后端以及与前端交互的时候是一个很好用的技能，因此我们即使不看本篇文章，也一定要自己积极主动了解相关内容！！**

## Exceptions（异常）： ##

在Java中，**异常（Exceptions）也是一种处理程序运行期间错误或异常情况的机制**。异常是通过Java中的类来表示的，这些类被称为异常类（Exception Classes）。

Java中的异常机制是基于“**抛出和捕获**”的原则。**当程序出现异常的时候，异常被创建并抛出（throw），然后在代码的其他地方被捕获（catch），并执行相应的处理逻辑。**

Java中的异常类是从 \`java.lang.Exception\` 类派生出来的。**异常类分为两类：检查异常（Checked Exceptions）和非检查异常（Unchecked Exceptions）。**

**1. 检查异常：**

*  检查异常是指在代码中可能出现的特定情况，需要显式处理。
 *  检查异常必须在方法的声明中声明或者在方法体内通过try-catch语句块捕获。
 *  例如：IOException、FileNotFoundException等。

**2. 非检查异常：**

*  非检查异常是指程序在运行时可能出现的异常情况。
 *  非检查异常通常是由程序错误导致的，如数组越界、除零错误等。
 *  非检查异常无需在方法声明或方法体内捕获，但可以选择捕获并进行处理。
 *  例如：NullPointerException、ArithmeticException等。

Java提供了多个关键字和语句来处理异常，其中包括：

*  try-catch语句用于捕获并处理异常。
 *  throws关键字用于声明可能抛出的异常类型。
 *  finally块用于定义无论是否出现异常都需要执行的代码。
 *  throw关键字用于手动抛出异常。

通过合理地处理异常，可以提高Java程序的健壮性和可靠性，确保程序在异常情况下仍能正常运行。

### 异常的两大作用： ###

**1.异常是用来查询bug的关键参考信息。**

假设你编写了一个处理用户登录的程序，其中包括一个用户验证的功能。如果用户提供的用户名不存在，你可能会抛出一个"UserNotFoundException"的异常。这个异常将包含有关错误的关键信息，如用户名，以便于在处理异常时进行调试和修复bug。

例如：

public class UserLogin {
      public void validateUser(String username, String password) throws UserNotFoundException {
        // 在数据库中查找用户
        if (!userExists(username)) {
          throw new UserNotFoundException("用户名不存在：" + username);
        }
        // 进行密码验证等其他操作
        // ...
      }
      
      private boolean userExists(String username) {
        // 查询数据库，判断用户是否存在
        // ...
      }
      
      // 其他代码
    }

在上面的例子中，如果用户提供的用户名在数据库中不存在，该程序将抛出一个"UserNotFoundException"异常，并传递包含错误信息的字符串。通过查看异常信息，你可以追踪到出错的位置，并在必要时修复bug，例如检查数据库查询逻辑等。异常信息对于开发人员来说是非常有用的，因为它们提供了有关bug发生位置和原因的重要线索。而我们以前还需要利用print手动输出一个“密码不存在”。

> **那为什么不选择打印报错呢？**
> 
> 这是因为抛出异常是一种更为灵活和规范的做法。它提供了一种统一的异常处理机制，使得调用者可以根据需要捕获和处理异常，而不仅仅是简单地打印错误信息。**异常还可以传递更详细的错误信息和上下文，方便调用者进行更高级的错误处理逻辑。打印错误信息虽然简单直接，但对于复杂的程序和错误处理需求来说可能不够灵活和可扩展。**而且异常抛出之后，程序就会直接停止执行，而我们的print打印报错对于编译器来讲只是正常的执行了一条打印语句，仍然会继续进行，需要我们自己手动停止。

**2.异常可以作为方法内部的一种特殊返回值，用来告知调用者底层的执行情况。**

public class FileProcessor {
        public void processFile(String fileName) throws FileProcessingException {
            try {
                // 打开文件，进行处理
                openFile(fileName);
                // 其他处理逻辑
                // ...
                // 关闭文件
                closeFile();
            } catch (IOException e) {
                // 处理文件操作异常
                throw new FileProcessingException("文件处理发生异常", e);
            }
        }
        
        private void openFile(String fileName) throws IOException {
            // 打开文件的逻辑
            // ...
        }
        
        private void closeFile() throws IOException {
            // 关闭文件的逻辑
            // ...
        }
    }

在上面的例子中，`FileProcessor`类的`processFile`方法用于处理指定文件。如果在处理文件的过程中发生文件操作异常（如文件无法打开、读取或关闭等），它将抛出一个`FileProcessingException`异常，并将底层的`IOException`作为原因传递给调用者。

通过这种方式，调用者可以捕获并处理异常，进一步了解底层执行情况，比如是否成功打开和关闭文件。异常提供了一种机制，允许将错误信息从方法的实现细节传递到方法的调用方，使得调用者可以根据需要采取适当的措施。

**异常作为方法内部的特殊返回值**与**其作为查询bug的关键参考信息**之间的**区别主要在于目的和使用方式**。它们都提供了有关底层执行情况的信息，**在方法内部作为返回值时，异常用于传达执行状态；而在查询bug时，异常信息用于诊断和调试错误的代码。**

### 异常的处理方式： ###

#### **1.JVM默认处理** ####

JVM默认的处理方式就是把异常的名称，异常原因，以及异常出现的位置等信息输出在控制台。而程序此时也会停止执行，不会再进行下面的语句。

例如直接执行这段代码：

public class test10 {
        public static void main(String[] args) {
            int[] arr = new int[3];
            System.out.println(arr[4]); // 数组越界异常
        }
    }

控制台就会输出：

![3738dc915f5d4b89984347a70f9c9579.png][]

####  **2.自己捕获异常** ####

我们自己捕获异常就是利用try和catch语句，自定义异常语句以及出现异常之后的执行策略。

格式为：

try{
    可能出现异常的代码；
    }
    catch{
    异常的处理代码
    }

目的：**当代码出现异常的时候，可以让程序继续往下执行。并不会像JVM默认处理的时候那样，直接停止程序。**

public class test10 {
        public static void main(String[] args) {
            try {
                int result = divide(10, 0); // 调用自定义的除法方法
                System.out.println("结果：" + result);
            } catch (ArithmeticException e) { // 捕获特定类型的异常
                System.out.println("除数不能为零！");
                e.printStackTrace(); // 打印堆栈跟踪
            }
            System.out.println("我可以被执行！");
        }
    
        public static int divide(int dividend, int divisor) {
            return dividend / divisor; // 可能引发除零异常的除法操作
        }
    }

执行结果为：

![55a93e1e6507492d952d1541139b9d7d.png][]

**try捕捉异常的三种情况：**

*  **每个异常被不同的 `catch` 块捕获和处理：在 `try` 块中的每个可能抛出异常的语句都有对应的 `catch` 块来捕获和处理该异常。这样可以根据不同的异常类型执行适当的处理逻辑。**

try {
        // 可能抛出异常的语句1
        // 可能抛出异常的语句2
        // ...
    } catch (ExceptionType1 e1) {
        // 处理异常类型1
    } catch (ExceptionType2 e2) {
        // 处理异常类型2
    } catch (ExceptionType3 e3) {
        // 处理异常类型3
    }

*  **多个异常被同一个 `catch` 块捕获和处理：如果多个异常属于同一个异常类型的子类型，可以使用同一个 `catch` 块捕获和处理它们。这种情况下，可以通过异常对象的属性或方法来区分和处理不同的子类型异常。**

try {
        // 可能抛出异常的语句1
        // 可能抛出异常的语句2
        // ...
    } catch (ParentExceptionType e) {
        // 处理多个异常类型
    }

*  **异常被上层的 catch 块捕获：如果在 `try` 块中的某个 `catch` 块成功捕获了一个异常，且没有在其中抛出新的异常，那么该异常会被视为已被处理，并不会传递到下一个 `catch` 块。**

try {
        // 可能抛出异常的语句1
        // 可能抛出异常的语句2
        // ...
    } catch (ExceptionType1 e1) {
        // 处理异常类型1，并不再传递异常
    } catch (ExceptionType2 e2) {
        // 处理异常类型2
    }

*  **如果我们tyr中的异常没有被捕获（例如抛出了数组越界异常，但是我们只写了判断空指针异常，此时的异常就没有被catch捕获），那么我们就会执行JVM的默认处理方式。**

**捕捉异常的注意点：**

**1.如果我们要捕捉多个异常，且这些异常中存在父子关系，那么父类一定要在最下面**

> **这么写是catch匹配异常是从上往下进行匹配的，而父类异常可以接受所有的子类异常，这就导致所有的异常走到父类异常这里都会被接受，而后面的子类异常接收不到任何异常，导致子类异常被父类异常接受，可能无法得到我们想要的结果，因此我们要把父类异常放到子类异常的最下面。**

如果你想捕获所有可能抛出的异常，可以使用**`Exception`**类作为`catch`块的参数。这样可以捕获到所有派生自`Exception`的异常。

try {
        // 可能抛出异常的语句
    } catch (Exception e) {
        // 处理异常
    }

如果你想捕获特定类型的异常，可以使用该异常类或其子类作为`catch`块的参数。

try {
        // 可能抛出异常的语句
    } catch (ArithmeticException e) {
        // 处理算术异常
    } catch (NullPointerException e) {
        // 处理空指针异常
    } catch (IOException e) {
        // 处理输入输出异常
    }catch (Exception e) {
        // 处理异常
    }

通过掌握父类和子类之间的关系，可以更有效地处理不同类型的异常，并为程序提供适当的错误处理机制。

2.**try中只要产生了一个异常，try的剩下部分就会被跳过，因此我们不可以在一个try中写多个异常语句，这是没有用的，只会执行第一个异常，而我们写这么多的catch，意义在于针对这一个异常，我们要针对性的捕获它！**

public class test10 {
        public static void main(String[] args) {
            try {
                int[] numbers = {1, 2, 3};
                System.out.println(numbers[4]); // 数组越界异常
                
                int result = divide(10, 0); // 除零异常
                System.out.println("结果：" + result);
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("捕获到数组越界异常！");
                e.printStackTrace();
            } catch (ArithmeticException e) {
                System.out.println("捕获到除零异常！");
                e.printStackTrace();
            } catch (Exception e) {
                System.out.println("捕获到其他异常！");
                e.printStackTrace();
            }
    
            System.out.println("异常处理完成！");
        }
    
        public static int divide(int dividend, int divisor) {
            return dividend / divisor;
        }
    }

执行结果：

![129cd3a3efd94b8f90bccf0fe12d5b57.png][]

我们可以看到除零异常根本不会被捕获，因为第一个数组越界异常发生以后，try语句中的所有剩余都会被跳过。

**手动捕获异常处理中的常见方法：**

`Throwable` 是Java中所有异常类的根类，它定义了一些常用的方法，可以在异常处理中使用。下面是一些常用的 `Throwable` 方法：

*  **`getMessage()`**：返回异常的详细描述信息。

try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        System.out.println(e.getMessage()); // 打印异常信息
    }

*  **`printStackTrace()`**：将异常的跟踪栈信息输出到标准错误流（`System.err`），可以用于调试和定位异常发生的位置。

try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        e.printStackTrace(); // 输出异常跟踪栈信息
    }

*  **`getCause()`**：返回导致当前异常的原因异常，通常用于嵌套异常场景。

try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        Throwable cause = e.getCause();
        if (cause != null) {
            System.out.println("导致异常的原因：" + cause.getMessage());
        }
    }

*  **`getLocalizedMessage()`**：返回异常本地化描述信息，如果该异常类提供了本地化描述，则返回本地化描述信息，否则返回异常描述信息。

try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        System.out.println(e.getLocalizedMessage()); // 打印异常的本地化描述信息
    }

*  **`toString()`**：返回异常的字符串表示，包括异常类名和详细描述信息。

try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        System.out.println(e.toString()); // 打印异常的字符串表示
    }

这些是 `Throwable` 类的一些常用方法。需要注意的是，`Throwable` 还有其他的方法和一些子类的特定方法，可以根据需要进一步了解和使用。

#### **3.抛出处理** ####

![de71b4f338214faab07c740830793f44.png][]

**throws：**

**`throws` 关键字用于在方法声明中指定该方法可能抛出的异常类型。通过使用 `throws` 关键字，可以将异常传递给调用者或上层代码来处理，而不是在方法内部进行捕获和处理。**

下面是一个使用 `throws` 的简单例子：

import java.io.FileNotFoundException;
    import java.io.FileReader;
    
    public class FileProcessor {
        public static void main(String[] args) {
            try {
                readFile("file.txt");
            } catch (FileNotFoundException e) {
                System.out.println("文件不存在！");
                e.printStackTrace();
            }
        }
    
        public static void readFile(String fileName) throws FileNotFoundException {
            FileReader fileReader = new FileReader(fileName);
            // 进行文件读取操作
            // ...
        }
    }

在上述代码中，我们有一个 `readFile` 方法，用于从指定的文件中读取内容。**由于读取文件可能会发生文件不存在的异常，因此在方法声明中使用 `throws` 关键字指定了可能抛出的 `FileNotFoundException` 异常。**

在 `main` 方法中调用 `readFile("file.txt")` 时，如果文件不存在，将会抛出 `FileNotFoundException` 异常。由于我们使用了 `throws` 来声明可能抛出的异常，因此需要通过在 `main` 方法中使用 `catch` 块来捕获并处理该异常。

**通过使用 `throws`，我们可以将异常的处理责任交给调用者或上层代码，从而使代码更加模块化和灵活。调用者可以选择捕获并处理异常，或继续向上层代码传递异常，直到有相应的异常处理机制为止。**

**throw：**

**`throw` 关键字用于手动抛出一个异常。它可以用于任何地方，包括方法、构造函数、代码块和其他异常处理机制中。通过使用 `throw` 关键字，可以在程序中指示错误或异常情况，并将控制权交给上层代码或异常处理机制来处理。**

抛出异常的一般语法如下：

throw throwableObject;

其中，`throwableObject` 是要抛出的异常对象，可以是 Java 内置的异常类（如 `RuntimeException`、`IOException` 等）或自定义的异常类的实例。

以下是一个使用 `throw` 抛出异常的例子：

public class AgeValidation {
        public static void main(String[] args) {
            try {
                int age = -5;
                validateAge(age);
            } catch (IllegalArgumentException e) {
                System.out.println("年龄无效！");
                e.printStackTrace();
            }
        }
    
        public static void validateAge(int age) {
            if (age < 0) {
                throw new IllegalArgumentException("年龄不能为负数！");
            }
            System.out.println("年龄有效！");
        }
    }

在上述代码中，我们有一个 `validateAge` 方法，它接收一个年龄作为参数，并通过判断年龄是否为负数来验证年龄的有效性。如果年龄为负数，则使用 `throw` 关键字手动抛出一个 `IllegalArgumentException` 异常，并提供错误消息 “年龄不能为负数！”。

在 `main` 方法中调用 `validateAge(-5)` 时，传入了一个负数作为年龄，触发了异常的抛出。然后，在 `catch` 块中捕获并处理该异常。

**通过使用 `throw`，我们可以在需要的时候手动抛出异常，以便在程序中指示错误或异常情况，并将异常控制权交给上层代码或异常处理机制。这有助于提高程序的可读性和可维护性，并实现更精确的异常处理。**

**throw与throws的区别：**

`throw` 和 `throws` 是在异常处理中使用的关键字，它们有以下差别：

1.  **功能不同：**
    
     *  `throw` 用于主动抛出异常。它可以在任何地方使用，用于手动抛出一个异常对象。
     *  `throws` 用于在方法声明中指定该方法可能抛出的异常类型。它用于向调用者或上层代码声明当前方法可能会抛出的异常，以便调用者能够适当地处理异常。
2.  **使用位置不同：**
    
     *  `throw` 关键字可以用于方法、构造函数、代码块或其他异常处理机制内部的任何位置。
     *  `throws` 关键字只能在方法或构造函数的声明部分使用，用于指定该方法可能抛出的异常。
3.  **异常处理责任不同：**
    
     *  使用 `throw` 抛出异常后，控制权会立即转移到调用栈中的适当的异常处理机制，如 `try-catch` 块。
     *  使用 `throws` 声明异常后，方法仍然可以继续执行，并将异常的处理责任交给调用该方法的代码。

综上所述，throw 用于手动抛出异常，而 throws 用于在方法声明中指定可能抛出的异常类型。throw 直接触发异常并将控制权转移给异常处理机制，而 throws 声明异常后，方法仍然会执行，将异常抛给调用者处理。

## 自定义异常： ##

在Java中，可以通过创建自定义异常类来实现用户定义的异常。**自定义异常类可以根据特定的业务需求或异常情况，提供更具体、更清晰的异常信息，并允许开发者以自定义的方式处理异常**。

创建自定义异常类的步骤如下：

1.  创建一个继承自 `Exception` 或其子类的类，并命名为你想要的异常类名。
2.  在自定义异常类中，可以添加自定义的构造方法和其他方法，用于初始化异常对象和提供额外的异常信息。
3.  可以选择重写父类的方法，或添加自定义的方法来满足特定的需求。例如，可以添加方法来获取更详细的异常信息。

下面是一个简单的自定义异常类的例子：

public class InvalidAgeException extends Exception {
        private int age;
    
        public InvalidAgeException(int age) {
            super("年龄不合法！");
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    }

在上述代码中，我们创建了一个自定义的异常类 `InvalidAgeException`，它继承自 `Exception` 类。该异常类具有一个带有参数的构造方法，用于初始化异常对象，并提供年龄信息。我们还添加了一个 `getAge` 方法，用于获取年龄信息。

**使用自定义异常类时，可以在代码中以相同的方式处理它们，就像处理内置的异常类一样。例如，可以使用 `try-catch` 块来捕获和处理自定义异常。**

以下是一个使用自定义异常的示例：

public class AgeValidation {
        public static void main(String[] args) {
            try {
                int age = -5;
                validateAge(age);
            } catch (InvalidAgeException e) {
                System.out.println("年龄无效！年龄为：" + e.getAge());
                e.printStackTrace();
            }
        }
    
        public static void validateAge(int age) throws InvalidAgeException {
            if (age < 0) {
                throw new InvalidAgeException(age);
            }
            System.out.println("年龄有效！");
        }
    }

在上述代码中，我们使用自定义异常类 `InvalidAgeException` 来实现对年龄的验证。当年龄为负数时，我们使用 `throw` 关键字抛出 `InvalidAgeException` 异常，并将年龄作为参数传递给异常构造方法。在 `main` 方法中，通过 `try-catch` 块捕获并处理该异常。

**自定义异常类的使用可以提供更具体和详细的异常信息，使异常处理更精确和可控。它可以让开发者根据特定的业务需求创建和处理异常，从而提高程序的可读性和可维护性。**

## 异常的优点： ##

1. **异常处理机制**：异常提供了一种结构化的错误处理机制，使开发者能够更容易地检测、捕获和处理错误。通过合理使用异常处理，可以提高代码的可维护性和可读性。

2. **分离正常流程和异常处理逻辑**：异常机制将正常的业务逻辑与异常处理逻辑分离开来。这样，在编写代码时，可以将主要注意力放在正常情况下的逻辑流程上，而将异常情况作为特殊情况进行处理。

3. **提供错误信息和堆栈追踪**：异常对象中包含有关错误的详细信息，例如异常类型、错误消息和堆栈追踪。这些信息能够帮助开发者快速定位和解决问题，缩短调试时间。

4. **异常传播和处理**：异常机制允许异常在调用栈中传播，直到被捕获并处理。这意味着一个方法中的异常可以由该方法的调用者捕获和处理，使得异常的处理可以在不同的层次上进行。

5.**提高代码可靠性和稳定性**：通过捕获和处理异常，可以防止程序因遇到错误而崩溃或产生不可预测的行为。合理处理异常可以增强代码的健壮性，使程序更可靠和稳定。

6. **资源释放**：异常处理机制还可以确保在异常情况下正确释放和关闭系统资源，避免资源泄露和其他问题。

## 总结： ##

本文我们为大家详细的介绍了关于异常的知识点，异常的使用可以让我们提高对代码的掌控能力，异常就像手术刀一样，可以精准的切割我们的bug部分，使我们快速的对代码进行修改，异常是一种强大的错误处理工具，可以帮助开发者优雅地处理异常情况，提高代码的可靠性和可维护性。合理地使用异常处理机制可以改善程序的质量，提高开发效率。

如果我的内容对你有帮助，请**点赞，评论，收藏**。创作不易，大家的支持就是我坚持下去的动力！

![69e9169c980f43e0aad31ff9ada88a9c.png][]

[69b6760388dc4298b817e182f61921c0.png]: https://img-blog.csdnimg.cn/69b6760388dc4298b817e182f61921c0.png
[3738dc915f5d4b89984347a70f9c9579.png]: https://img-blog.csdnimg.cn/3738dc915f5d4b89984347a70f9c9579.png
[55a93e1e6507492d952d1541139b9d7d.png]: https://img-blog.csdnimg.cn/55a93e1e6507492d952d1541139b9d7d.png
[129cd3a3efd94b8f90bccf0fe12d5b57.png]: https://img-blog.csdnimg.cn/129cd3a3efd94b8f90bccf0fe12d5b57.png
[de71b4f338214faab07c740830793f44.png]: https://img-blog.csdnimg.cn/de71b4f338214faab07c740830793f44.png
[69e9169c980f43e0aad31ff9ada88a9c.png]: https://img-blog.csdnimg.cn/69e9169c980f43e0aad31ff9ada88a9c.png