Java 异常处理详解（如果想知道Java中有关异常处理的知识点，那么只看这一篇就足够了！）

1.异常的概念

       ——在学习Java中的异常之前，先让我们了解一下什么是Java中的异常：

       在 Java 中，异常（Exception）是指程序在执行过程中遇到的不正常情况，这些情况可能导致程序无法继续执行或产生错误的结果。异常可以是 Java 标准库中提供的内置异常类，也可以是开发人员自定义的异常类。

       相信读者在日常的编写代码的时候，或多或少的都遇到过一些异常，只是读者你可能没有太注意它们，比如如下异常：

1. NullPointerException（空指针异常）

空指针异常通常发生在尝试访问对象的属性或调用对象的方法时，而该对象为 null 的情况下。

public class NullPointerExceptionExample {
    public static void main(String[] args) {
        String str = null;
        System.out.println(str.length()); // 这行代码会抛出 NullPointerException
    }
}

2. ArrayIndexOutOfBoundsException（数组越界异常）

数组越界异常发生在尝试访问数组的不存在的索引位置时。

public class ArrayIndexOutOfBoundsExceptionExample {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[5]); // 这行代码会抛出 ArrayIndexOutOfBoundsException
    }
}

3. ArithmeticException（算术异常）

算术异常发生在进行除以零的算术运算时。

public class ArithmeticExceptionExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        System.out.println(a / b); // 这行代码会抛出 ArithmeticException
    }
}

       当然，这以上只是举出来几个常见的异常的案例，所以我们就可以知道了异常类型和如何处理它们对于编写健壮的 Java 代码非常重要。

2.异常的体系结构

       （1）异常的体系结构

       在Java中，Java 异常体系结构是由一组类构成的，它们都是 Throwable 类的子类。常见的异常类包括 Error、RuntimeException 以及它们的子类。Error 类及其子类通常表示严重的错误，如系统错误或虚拟机错误，程序通常无法恢复。RuntimeException 及其子类通常表示程序逻辑错误或运行时错误，如空指针异常、数组越界异常等。

我们可以直接看一下以下这幅图进行理解：

从上图中可以看到：

       1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception；

       2. Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回力乏术；

       3. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception；

       （2）异常的分类

       在Java中，异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为两类：

1.编译时异常：

       这是因为程序员必须处理这种异常，否则编译器会报错。在Java中最典型的编译时异常为FileNotFoundException，它会在尝试打开不存在的文件时抛出。

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
 
public class CompileTimeExceptionExample {
    public static void main(String[] args) {
        try {
            File file = new File("nonexistent_file.txt"); // 这里假设文件不存在
            FileReader fr = new FileReader(file); // 可能抛出 FileNotFoundException
        } catch (FileNotFoundException e) {
            System.out.println("文件未找到异常：" + e.getMessage());
        }
    }
}

注意：

       编译时出现的语法性错误，不能称之为异常。例如将 System.out.println 拼写错了, 写成了system.out.println. 此时编译过程中就会出错, 这是 "编译期" 出错。而运行时指的是程序已经编译通过得到class 文件了, 再由 JVM 执行过程中出现的错误.

2.运行时异常：

       这些异常不需要强制捕获或处理，因为它们通常是由程序逻辑错误引起的。一个常见的运行时异常是 ArrayIndexOutOfBoundsException，当尝试访问数组中不存在的索引时会抛出。

public class RunTimeExceptionExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        try {
            System.out.println(array[5]); // 可能抛出 ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界异常：" + e.getMessage());
        }
    }
}

这样我们就大致的了解了异常的体系结构了。

3.异常的抛出

       当然，在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测。在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

throw new XXXException("异常产生的原因");

让我们看一下一个案例：

public static void validateAge(int age) {
        if (age < 18) {
            //异常的抛出
            throw new InvalidAgeException("未满18岁，不允许访问。");
        }
        System.out.println("年龄验证通过。");
}

【注意事项】

1. throw必须写在方法体内部
2. 抛出的对象必须是Exception 或者 Exception 的子类对象
3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
5. 异常一旦抛出，其后的代码就不会执行

        这样我们就大致的了解了如果有异常之后，我们如果将其进行抛出了。但是异常是抛出了，那我们如何去解决抛出的异常呢？

4.异常的解决方式

       ——在Java中异常的具体处理方式主要有两种：异常声明 throws 以及 try-catch捕获处理。

       （1）异常声明throws

       当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。

其语法形式为：

修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
 
 
}

让我们直接使用一个案例来进一步帮助你进行理解：

public static void divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        int result = a / b;
        System.out.println("结果：" + result);
}

       我们可以在这个案例中看到，如果b == 0时，我们抛出了异常，但是我们并没有在此方法中对该异常进行处理，而是将其继续抛出，给调用者处理。这就是第一种处理异常的方式throws。

【注意事项】

1. throws必须跟在方法的参数列表之后
2. 声明的异常必须是 Exception 或者 Exception 的子类
3. 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。

4. 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

       （2）使用try - catch - finally语句

       ——在Java中，异常可以通过try-catch-finally语句块来进行处理。由于throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要try-catch。

其基本语法为：

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理异常类型1的情况
} catch (ExceptionType2 e2) {
    // 处理异常类型2的情况
} finally {
    // 可选的finally语句块，用于执行清理操作
}

       在try语句块中，我们可以放置可能抛出异常的代码。如果try语句块中的代码抛出了异常，那么异常会被catch语句块捕获。catch语句块中的参数指定了要捕获的异常类型，当抛出的异常与catch语句块中指定的类型匹配时，相应的catch语句块会被执行。如果try语句块中的代码未抛出异常，则catch语句块会被跳过。

       另外，finally语句块是可选的，用于执行清理操作，无论是否发生异常都会执行。finally语句块通常用于释放资源或执行必要的收尾工作，例如关闭文件或数据库连接。

这里我们使用一个案例来帮助你进一步理解：

public class SimpleExceptionHandlingExample {
 
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int result = 0;
        try {
            // 尝试进行除法运算
            result = a / b;
            System.out.println("除法运算结果：" + result);
        } catch (ArithmeticException e) {
            // 捕获除零异常并输出错误信息
            System.err.println("除法运算出错：除数不能为零");
        } finally {
            // 无论是否发生异常，都会执行的代码块
            System.out.println("finally块：结束异常处理");
        }
    }
}

       首先我们对10除以0进行除法运算。由于除数为0，会抛出ArithmeticException异常。我们在try块中捕获这个异常，并输出错误信息。无论是否发生异常，finally块中的代码都会执行，这里我们简单输出一条结束异常处理的消息。

【注意事项】

1. try块内抛出异常位置之后的代码将不会被执行
2. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的

3. try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获

4. 如果多个异常的处理方式是完全相同，我们可以使用“ | ”隔开

5. 如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误

这里我们对第四条加以解释：如果多个异常的处理方式是完全相同，我们可以使用“ | ”隔开

例如：

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
    //对异常进行处理的代码
}

       ——当然我们可以一直 | 添加异常，但是实际上不建议使用这样的方式处理，因为这样处理我们将不知道到底try中代码出现了什么类型的异常     （比如上面的代码可能出现的异常类型为ArrayIndexOutOfBoundsException ，也可能是 NullPointerException异常类型）

这样我们就大致的了解了Java处理异常的两种方式了。

补充：异常处理流程总结

       1. 程序先执行 try 中的代码.
       2. 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
       3. 如果找到匹配的异常类型, 就会执行 catch 中的代码.
       4. 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
       5. 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
       6. 如果上层调用者也没有处理的了异常, 就继续向上传递.
       7. 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

5.自定义异常

说到自定义异常，我们首先要了解一下什么是自定义异常：

       自定义异常是指由开发人员根据实际需求创建的异常类，它们扩展自Java标准库中的Exception或其子类。与标准异常类不同，自定义异常类可以提供更具体的异常信息、更详细的上下文信息，以及针对特定业务逻辑的错误处理逻辑。

了解完了什么是自定义异常之后，先让我们看一下如何去创建一个自定义异常。

创建一个自定义异常类，方式如下：

       1. 自定义异常类，然后继承自Exception 或者 RunTimeException

       2. 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因

例子：

// 自定义运行时异常类
class InvalidAgeException extends RuntimeException {
    // 无参构造方法
    public InvalidAgeException() {
        super("年龄无效");
    }
 
    // 带有异常消息的构造方法
    public InvalidAgeException(String message) {
        super(message);
    }
}

       这样我们就创建好了一个自定义异常了，那么自定义异常创建好之后，我们又该如何的使用它呢？让我们继续往下看！

现在我们将要使用刚才创建好的自定义异常类来完成一个小案例：（代码如下）

// 创建人类
class Person {
    private String name;
    private int age;
 
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        // 检查年龄是否有效，如果无效则抛出自定义异常
        if (age < 0 || age > 150) {
            //使用了我们刚才创建的自定义异常类
            throw new InvalidAgeException("年龄必须在0到150之间");
        }
        this.age = age;
    }
 
    // 获取年龄
    public int getAge() {
        return age;
    }
}
 
//测试类
public class CustomRuntimeExceptionExample {
    public static void main(String[] args) {
        // 创建一个人类对象，年龄为负数，会抛出自定义异常
        try {
            Person person = new Person("Alice", -10);
            System.out.println(person.getAge());
        } catch (InvalidAgeException e) {
            // 捕获并处理自定义异常
            System.err.println("创建人物失败：" + e.getMessage());
        }
 
        // 创建一个人类对象，年龄超过有效范围，也会抛出自定义异常
        try {
            Person person = new Person("Bob", 160);
            System.out.println(person.getAge());
        } catch (InvalidAgeException e) {
            // 捕获并处理自定义异常
            System.err.println("创建人物失败：" + e.getMessage());
        }
    }
}

       在上面的代码中，我们首先定义了一个名为InvalidAgeException的自定义异常类，它继承自RuntimeException类。然后我们定义了一个Person类，其中包含一个构造方法用于创建人类对象，并在构造方法中检查年龄是否有效。如果年龄无效，则抛出InvalidAgeException异常。

       然后在main方法中，我们分别创建了两个Person对象，一个年龄为负数，一个年龄超过有效范围。在创建这两个对象时，都会抛出自定义异常。我们使用try-catch语句块捕获并处理这些异常，输出错误信息到控制台。

       通过这个案例我相信读者你已经大致的了解了如何创建一个自定义异常类和如何去使用创建的自定义异常类了。

注意事项：

1. 自定义异常通常会继承自 Exception 或者 RuntimeException
2. 继承自 Exception 的异常默认是受查异常
3. 继承自 RuntimeException 的异常默认是非受查异常.

这样我们就了解了Java中自定义异常了。