当前位置： 首页 > news >正文

【JavaSE】异常

news 来源：原创 2025/6/20 17:08:41

【JavaSE】异常

  • 一、 异常的概念与体系结构
    • 1.1 异常的概念
    • 1.2 异常的体系结构
    • 1.3 异常的分类
  • 二、 异常的处理
    • 2.1 防御式编程
    • 2.2 异常的抛出
    • 2.3 异常的捕获
      • 2.3.1 异常声明 throws
      • 2.3.2 try-catch 捕获并处理
      • 2.3.3 finally：和 try catch 并列的语句块
  • 三、 自定义异常类

一、 异常的概念与体系结构

1.1 异常的概念

异常：程序运行过程中，产生的一种“出错”的情况。

此处区别 —— 运行 / 编译：
（1）编译错误

在这里插入图片描述

（2）异常：是运行过程中出现的情况。

a. 异常实例1 ：0作为除数，出现算数异常
在这里插入图片描述
b. 异常实例2：0.0 作为除数，不报错

在这里插入图片描述
c. 数组越界异常

在这里插入图片描述

d. 空指针异常

在这里插入图片描述

1.2 异常的体系结构

异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：
在这里插入图片描述
Error：属于JVM内部使用的，程序员写代码，一般用不上Error。
Exception：包含很多的异常类。

总结：

  1. 整个Java标准库提供了很多现成的异常。
  2. 整个异常体系中分成两个大类，Error（JVM用）、Exception（程序员用）。

1.3 异常的分类

异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为（Exception 类型里面，又分成两种异常）：

  1. 受查异常：写代码的时候，这样的异常必须要显式处理。
  2. 非受查异常：写代码的时候，异常可以不显式处理。

受查异常 实例：

非受查异常 实例 ：

二、 异常的处理

2.1 防御式编程

错误在代码中是客观存在的，因此我们要让程序出现问题的时候及时通知程序猿。

主要的方式：

  1. 事前防御型 LBYL: Look Before You Leap. 在操作之前就做充分的检查.
  • 事前防御型 伪代码举例：
    先判定上一步是否成功，成功了再下一步，不成功进行错误处理。

在这里插入图片描述
在这里插入图片描述

  • 缺陷：正常的流程和错误处理流程代码混在一起, 代码整体显的比较混乱。
  1. 事后认错型 EAFP: It’s Easier to Ask Forgiveness than Permission.
    “事后获取原谅比事前获取许可更容易”. 也就是先操作, 遇到问题再处理.
  • 事后认错型 伪代码举例：
    任何一个环节，出现问题，都会出现“异常 ”，异常可以有很多种不同的类型。

在这里插入图片描述

  • 优势：
    正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码 。
    异常处理的核心思想就是 EAFP。

在Java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

2.2 异常的抛出

在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。
具体语法如下：

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

异常抛出实例：

public static int getElement(int[] array, int index){
	if(null == array){
	throw new NullPointerException("传递的数组为null");
	}
	if(index < 0 || index >= array.length){
		throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
	}
	return array[index];
}
public static void main(String[] args) {
	int[] array = {1,2,3};
	getElement(array, 3);
}

【注意事项】

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

2.3 异常的捕获

异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws 以及 try-catch捕获处理。

2.3.1 异常声明 throws

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

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

异常声明 实例：加载指定的配置文件config.ini

在这里插入图片描述

throws 和 throw 的区别：

  1. throw ：真的抛出一个异常对象
  2. throws：只是声明可能抛出一些异常对象（实际抛没抛出？不知道）

【注意事项】

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

2.3.2 try-catch 捕获并处理

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

import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo5 {
    //通过这个方法打开读取 一个配置文件的内容
    private static void openConfig(String filename) throws IOException {
        if(!filename.equals("config.txt")){
            throw new FileNotFoundException("文件不存在");
        }
            throw new IOException("文件读取失败");
    }

    //从数组中获取一个元素
    public static int getElem(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) throws FileNotFoundException {
        try{
            openConfig("xxx");
            System.out.println("执行到这个地方，完成 openConfig方法 的调用");
        } catch (IOException e) {
            System.out.println("进入到异常处理逻辑中");
            //catch 语句中，一般会打印出异常的详细信息
            //printStackTrace()方法可以打印异常的详细信息，主要就是调用栈
            e.printStackTrace();
        }
    }
}

【注意事项】

（1）try-catch 捕获异常， try 块内抛出异常位置之后的代码将不会被执行

在这里插入图片描述

（2）printStackTrace()方法：调用栈，打印异常的详细信息
在这里插入图片描述
（3）catch 可以有多个，取决于 try 中可能抛出哪些异常

在这里插入图片描述
（4）如果抛出的异常，找到末尾也没有找到匹配的catch；这样的异常就会沿着方法的调用栈，往上层传递。

异常当前方法没有catch到，就会抛给上层调用者，继续处理。

//先是func1()，处理不了；
//交给func2()，也处理不了；
//再交给main()，进行处理（如果main()处理不了，抛给JVM，令程序崩溃）
public class Demo6 {
    public static void func1(){
        throw new NullPointerException("空指针异常");
    }
    public static void func2(){
        try{
            func1();
        }catch(IndexOutOfBoundsException e){
            System.out.println("1111111111");
        }
    }
    public static void main(String[] args) {
        try{
            func2();
        }catch(NullPointerException e){
            System.out.println("2222222222");
        }
    }

}

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

public class Demo8 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println("before");
            // arr = null;
            System.out.println(arr[100]);
            System.out.println("after");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("这是个数组下标越界异常");
            e.printStackTrace();
        } catch (NullPointerException e) {
            System.out.println("这是个空指针异常");
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
}
  • 如果多个异常的处理方式是完全相同, 也可以写成这样：

在这里插入图片描述

  • catch的时候，抛出子类，catch父类
    在这里插入图片描述
  • 如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误：
    在这里插入图片描述
  • catch Throwable：虽然可以捕获异常，但是无法区别具体是哪种异常在这里插入图片描述

2.3.3 finally：和 try catch 并列的语句块

  1. finally 语法格式：
        try{
// 可能会发生异常的代码
    }catch(异常类型 e){
// 对捕获到的异常进行处理
    }finally{
// 此处的语句无论是否发生异常，都会被执行到
    }
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行
  1. 程序释放需要finally在这里插入图片描述3. finally 作用

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。
另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

在这里插入图片描述

  1. try catch finally 的打印顺序和执行顺序不一样

在这里插入图片描述

在这里插入图片描述
4. finally中的return会覆盖掉 try catch中的 return 结果
在这里插入图片描述

【总结】

（1）try catch finally 基本语法结构
（2）异常处理代码的执行顺序：throw 出异常，try 后续的代码不再执行，进入匹配的 catch ,最后在执行 finally。
（3）多个catch 的匹配规则：从上到下，子类异常能够被父类捕获到。

三、 自定义异常类

异常就是类，自己写类，自己的类继承自标准库的异常类（Expetion、RuntimeException…）

自定义异常 实例：

//创建异常类
class UsernameExpection extends Exception{

}
class PasswordExpection extends Exception{

}

//实现登录的过程
class Login{
    private String username = "admin";
    private String password = "123456";

    public void login(String username,String password) throws UsernameExpection, PasswordExpection {
      /*  //事先防御型
        if(!username.equals(this.username)){
            System.out.println("用户名错误！");
            return;
        }
        if(!password.equals(this.password)){
            System.out.println("密码错误！");
            return;
        }
        System.out.println("登录成功！");*/



        if(!username.equals(this.username)){
            throw new UsernameExpection();
        }
        if( !password.equals(this.password)){
            throw new PasswordExpection();
        }
    }
}

public class Demo13 {
        public static void main(String[] args) {
            Login login = new Login();
            try {
                login.login("adim", "123456");
            } catch (UsernameExpection e) {
                System.out.println("用户名错误！");
            } catch (PasswordExpection e) {
                System.out.println("密码错误！");
            }
        }
}

引入自定义异常，目的就是为了后续能够快速得找到出现问题的原因。

相关文章：

  • OSPF基础入门篇②：OSPF邻居建立篇-网络设备的“社交礼仪“
  • Android里蓝牙使用流程以及问题详解
  • 深度强化学习基础 0：通用学习方法
  • 架构演进成熟度校验体系构建
  • MyBatis批量更新之CASE WHEN方式详解
  • 找搭子系统 搭子经济新风口 基于精准匹配的社交新生态探索
  • React + TipTap 富文本编辑器 实现消息列表展示，类似Slack，Deepseek等对话框功能
  • 基于二叉堆实现的 PriorityQueue
  • LLM应用实战2-理解Tokens
  • C语言malloc类函数详解
  • Linux C 与 C 语言的区别及开发差异
  • Spring MVC 请求类型注解详解
  • Java-多级排序结合thenComparing()
  • 四六级听力考试播音系统:构建播放控制智能化、发射系统双备份、发射功率有冗余、安全稳定可靠的英语四六级听力播音系统使用环境
  • vue-element-plus-admin的安装
  • pytorch小记（十六）：PyTorch中的`nn.Identity()`详解：灵活模型设计的秘密武器
  • Linux内核——X86分页机制
  • I/O进程4
  • 动态规划系列一＞卡特兰数-不同的二叉搜索树
  • C# 串口通信
  • 网站建设优化西安/青岛设计优化公司
  • 国内网站是cn还是com/seo确定关键词
  • 论坛网站怎么做/视频剪辑培训机构
  • javascript怎么读/充电宝关键词优化
  • 做网站的图片分类/seo推广哪家公司好
  • 快速建网站软件/优化网站搜索排名