珊珊老师 的笔记

做最负责任的教育~我是执行者珊珊

2025-06-25 15:58

Java异常的初步认识

珊珊老师

Java后端

(78)

(0)

收藏

1. 异常的概念与体系结构

异常的概念：

    在Java中，将程序执行过程中发生的 不正常行为 或 非预期事件 称为异常。

异常对象：

    为了表示异常，Java使用了异常类来把不正常事件封装成了异常对象。在运行期间，这些异常对象会由系统根据错误类型自动创建，并把错误信息和上下文一并封装进对象中。

    例如：下面的代码会触发空指针异常。

    public static void main(String[] args) {
        int[] arr = null;
        System.out.println(arr[3]);
    }

image.png

本次异常信息显示：

  • 触发异常的是主线程main；

  • 触发的异常类型是NullPointerException(空指针异常)；

  • 给出解释：不能使用arr数组，因为它为空null；

  • 触发语句所在位置是：exception包底下的 Test1类中的 main方法里面的 第10行位置。

  • 这些异常信息全部都封装在系统创建的异常对象中。


1.1 异常类的总架构

刚刚解释了什么是异常和异常对象，它里面大概有什么内容，也了解到异常对象是根据异常类来创建的。那么异常类是什么呢？异常类有多少呢？

异常种类繁多，请看下图：

image.png

异常类的概念：

    广义上，异常类指的是Throwable的子类（严格来说Throwable不是异常类）。狭义上，异常类指的是Exception类及其子类。


从上图中可以看到，Throwable后面产生了2个分支：

  • Throwable：是异常体系的顶层类，但其本身不是异常类，它派生出两个重要的子类, Error 和 Exception（有且只有这两个分支）。

  • Error（错误）：指的是JVM无法解决的严重问题（系统级别的问题）。比如：JVM的内部错误、资源耗尽等，典型代表： StackOverflowError 和 OutOfMemoryError，一旦发生回力乏术。

  • Exception（异常）：异常产生后程序员可以通过代码进行处理，使程序继续执行。这种异常类似感冒、发烧，是可以通过一些手段治好的。我们平时所说的异常就是Exception。

栈溢出错误的举例：StackOverflowError

    public static void main(String[] args) {
        func();
    }
    public static void func(){
        func();
        return;
    }

image.png

1.2 Exception 狭义体系下的异常分类（异常抛出的时机）

    在Exception异常体系下，我们把异常分为 运行时异常 与 编译时异常。

    运行时异常：(Runtime Exceptions)

    定义：指的是 RuntimeException类及其子类。

    特点：该类异常在运行期间才检查。

    编译时异常：(无官方对应术语)

    定义：指的是所有继承自 Exception 但不继承 RuntimeException 的异常类。

    特点：该类异常在编译期间检查。

    注意：对于异常的检查，运行时异常发生在编译期间，编译时异常发生在运行期间。异常的 触发 和 抛出 都发生在运行期间。(3种行为的执行顺序是：检查 ——> 触发 ——> 抛出。)

    检查：检查程序员是否存在处理异常的策略。

    触发：检查是否发生了异常，如果发生了就是触发。

    抛出：确定异常已经发生后，抛出异常是一种处理异常的策略。(异常的处理策略包括抛出 和 捕获处理)

    运行时异常 和 编译时异常的图示：运行时异常是黄色部分，编译时异常是绿色部分。

image.png

1.3 Throwable 广义体系下的异常分类

    只要是Throwable及其子类，都可以称为异常，所以error这样的系统级错误也是广义上的异常。广义的异常可以分成 受查异常 和 非受查异常。

    受查异常：(Checked Exceptions)

    囊括的范围：编译时异常。

    特点：编译器会强制要求我们处理（例如throws、try-catch）。在IDEA上，如果我们没对受查异常进行处理，那么会在可能触发受查异常的地方画上红色波浪线。

    非受查异常：(Unchecked Exceptions)

    囊括的范围：运行时异常（Runtime Exceptions）和 错误（errors）。

    特点：编译器不会强制要求我们处理。

    补充：

        其实编译时异常是中文口语而非官方叫法，受查异常(Unchecked Exceptions)才是官方叫法。本身 “在编译期间检查” 和 “编译器强制处理” 这两个特点都是受查异常的特点，而且并没有一种错误或异常会在编译期间触发和抛出。

    受查异常 和 非受查异常的图示：非受查异常是蓝色部分，受查异常是红色部分。

image.png

1.4 异常对象的创建和打印

    在 Java 中，异常对象的管理和打印机制是 JVM 和 Java 标准库共同实现的。以下是关于异常对象创建、构造方法选择及打印机制的详细解析：

    JVM 在执行字节码时，会监控特定指令。当代码中发生异常时，JVM 会自动创建异常对象。

    printStackTrace()方法

    作用：用于输出异常的堆栈轨迹 和 错误信息。

    JVM自动打印：当异常对象创建出来后，如果无方法处理，那么异常对象就会一直往上层方法抛，直到抛给JVM。JVM会自动调用异常对象的printStackTrace()方法，并终止该线程。

    例如：JVM自动创建算术异常对象，由JVM打印后终止了程序，后面的代码不执行

    public static void main(String[] args) {
        System.out.println(8 / 0);  //触发算术异常
        //程序终止，后面的内容不执行
        System.out.println(111);
        System.out.println(222);
    }

image.png

如果异常是从深层方法抛出的，那么堆栈轨迹会把上抛的路线描述出来。 

除了JVM自动创建异常对象，我们也可以通过异常类的构造方法手动创建异常对象并手动调用printStackTrace()方法，这里介绍2种构造方法：

1. 无参构造方法：如Exception() 

    显示的错误信息：默认构造方法，无详细错误信息。

2. 一个参数的构造方法，参数类型为String：如Exception(String message)

    显示的错误信息：message参数就是错误信息的详细描述，由程序员详细描述。

例如：

    public static void main(String[] args) {
        RuntimeException e1 = new RuntimeException();
        RuntimeException e2 = new RuntimeException("由程序员描述异常信息");
        e1.printStackTrace();
        e2.printStackTrace();
    }

image.png

这里为了演示才专门创建出异常对象并打印，在实际开发中我们是在抛出异常的同时new出异常对象的，而不是现在这样创建异常对象但不抛出和处理。

2. 与异常相关的5个关键字

Error错误是系统级别的错误，无法干预纠正。但Exception异常是我们程序员可以通过代码来处理的，使程序继续正常运行。为了方便处理异常，Java提供了5个关键字：throw、throws、try、catch、finally。

2.1 throw关键字 与 throws关键字

1. 异常的手动抛出：throw 

throw关键字

作用：

  • 显式抛出一个异常对象，抛出的对象只能是 Exception 或其子类对象。

  • 由于是手动 throw 出异常，所以异常对象也要手动 new 创建。

  • 异常一旦被抛出，其后的代码都不执行。(中断当前执行流)

注意：throw 必须写在方法体内部。

    public static void main(String[] args) {
        int[] arr = null;
        if(arr == null){
            throw new NullPointerException("数组arr不能为空");
        }
        //抛出异常后，后面的代码不执行
        System.out.println(3+5);
    }

异常对象抛出后，后面的代码不执行，所以不会打印8：

image.png

2. 异常抛出的显式声明：throws

throws关键字

作用：

  • 在方法签名(方法头)后面 声明该方法可能抛出的异常。

  • throws 后面是抛出的异常类型，数量可以多个，用“,”逗号隔开。

  • 如果本层方法(手动或自动)抛出的异常是受查异常，那么必须使用throws关键字声明；非受查异常无强制要求。

2.2 try-catch 语句

throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者（上层方法），由调用者处理。如果真正要对异常进行处理，就需要try-catch。

注意：try语句只能有一个。

标准流程：

  • 先执行try代码块中的代码，如果某一条语句触发了异常，那么try代码块将终止执行。

  • 触发异常后，会跳转到catch语句从上往下进行匹配。如果异常对象是某个catch异常参数类型的同类或子类，那么程序将进入该catch代码块并对异常进行处理。

  • 其中一个catch代码块捕捉并处理异常后，直接退出整个try-catch，继续执行后面的代码。

例如：

    static int getElement(int[] arr, int index){
        if(arr == null){
            throw new NullPointerException();
        }
 
        if(index < 0 || index >= arr.length){
            throw new ArrayIndexOutOfBoundsException();
        }
 
        return arr[index];
    }
 
    public static void main(String[] args) {
        try {
            int[] arr = null;
            getElement(arr, 5); //抛出空指针异常
        } catch (NullPointerException e) {      //匹配到处理到该catch
            System.out.println("空指针异常的处理");
        } catch (ArrayIndexOutOfBoundsException e){ //异常已处理，跳过该catch语句
            System.out.println("下标越界的异常处理");
        }
        //异常处理完毕，程序继续运行
        System.out.println(3+5);
    }

catch 的特点：

  • 在没有finally的try-catch语句中，catch是必须存在的。

  • catch语句支持多捕获，即可以有多个catch。

  • 每个catch都是独立的代码块，括号()中的局部变量都有独立的作用域。

  • 在Java7及后续版本，catch语句的小括号()不仅可以是单个具体异常，也支持使用逻辑或“|” 来同时捕获多个异常合并处理。

  • 如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误。这样可以避免具体问题的掩盖。

2.3 finally 关键字

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行。比如程序中打开的资源：网络连接、数据库 连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。

另外，因为异常会引发程序的跳转，可能 导致有些语句执行不到，finally就是用来解决这个问题的。


3. 自定义异常类

java中虽然已经内置丰富的异常类，但是并不能完全表示实际开发中所遇到的一些异常。所以java语法支持我们自定义异常类。

注意：虽然技术上支持Error类的继承，但是Error类表示系统级的错误，强烈不推荐这样使用。而且try-catch语句不会捕获Error异常，自定义Error可能会忽略了异常处理，导致程序意外终止。

Java官方规范明确了Error类是给 JVM 或系统使用的错误类型，开发者不应主动抛出或处理。仅在 极端底层场景 中可能需要自定义 Error，例如JVM的扩展开发。

我们自定义异常类一般继承自Exception类 或 RuntimeException类。需要注意的是，Exception类是所有受查异常的基类，所以继承自Exception类的自定义异常是受查异常，继承自RuntimeException类的自定义异常是非受查异常。

自定义异常的具体步骤：

自定义异常类，类名一般带有"Exception"字样。然后继承自Exception 或者 RunTimeException。

重写一个带有String类型参数的构造方法，用来提供异常原因的描述。

例如写出一个登录异常类，用来辅助用户登录功能：

public class LoginException extends RuntimeException{ //自定义：登录异常类
    public LoginException(String message) {  //可供描述的构造方法
        super(message);
    }
}
 
public class Login extends RuntimeException{
    private String userName = "amy";    //被设置的用户名
    private String password = "123456"; //被设置的密码
 
    public Login(String userName, String password){
        if(this.userName.equals(userName) && !this.password.equals(password)){    //匹配账户密码
            throw new LoginException("密码输入错误 或 用户名不存在!");
        }
 
        System.out.println("登录成功");
    }
}
 
public class Demo3 {
    public static void main(String[] args) {
        try{
            Login login = new Login("amy", "654321");
        }catch (LoginException e){
            e.printStackTrace();
        }
        //成功登录后的后续操作
        //…………
    }
}

4. 防御式编程

错误在代码中是客观存在的，因此我们要让程序出现问题的时候及时通知程序员。此时防御式编程的思维就显得很重要了。

防御式编程是一种以预防为核心的编程方法论，旨在通过提前识别和处理潜在错误，提升代码的安全性和可靠性。其核心思想是“假设错误必然发生”，并通过设计防线来减少或消除错误的影响。

例如：拦截非法输入，预防逻辑错误扩散，减少因外部依赖故障导致的系统崩溃。

主要的方式可以分为事前防御型和事后认错型。


4.1 事前防御型

事前防御：(以预防为核心)

在问题发生前采取行动，通过预判风险、制定规则、建立机制等手段，主动阻止问题发生。

在Java代码中，常见的事前防御句式是 if + throw 。

例如：抛出空指针异常

    public void func(int[] arr){
        if(arr == null){
            throw new NullPointerException("数组arr为空");
        }
        //后续对数组arr的使用…………
    }

抛出断言错误：

    public static void func(int[] arr){
        if(arr == null){
            throw new AssertionError("参数不能为空引用");
        }
        //后续对数组arr的使用…………
    }

用前置条件 if 判断该代码运行的逻辑是否错误，如果错误就会执行throw语句。throw语句后面的语句都不再执行，把出现的问题给拦截了。


抛出的异常还能解决一下，要是抛出错误（例如此处的断言），则直接结束程序，让程序员解决完这个断言错误才能测试后面的代码运行。


4.2 事后认错型

事后防御：(以应对为核心)


在问题发生后采取行动，通过检测、修复、补救等手段，减少问题造成的损失或影响。



0条评论

点击登录参与评论

发表一篇笔记

今日最热笔记