JavaSE 异常

最新推荐文章于 2024-07-12 16:03:26 发布
最新推荐文章于 2024-07-12 16:03:26 发布
阅读量45 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mwt258/article/details/132748360
版权

Java SE 异常

文章目录

1. 异常介绍

1.1 异常的概念

在Java中，将程序执行过程中发生的不正常行为称为异常。

代码示例：

  1. 算术异常

    System.out.println(10/0);

//执行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero

  2. 数组越界异常

    int[] arr = {1,2,3};
System.out.println(arr[101]);

//执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 101

  3. 空指针异常

     int[] arr = null;
 System.out.println(arr.length);

//执行结果
Exception in thread "main" java.lang.NullPointerException

    从上述代码中可以看到，Java中不同类型的异常，都有与其对应的类来进行描述

1.2 异常的体系结构

异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：
在这里插入图片描述

从上图中可以看到：

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

  • Error：指的是Java虚拟机无法解决的严重问题，比如JVM的内部错误、资源耗尽等，典型代表有StackOverflowError和OutOfMemoryError

  • Exception: 异常产生后程序员可以通过代码进行处理，使程序继续执行

1.3 异常的分类

根据异常发生的时机不同，可以将异常分为：

  1. 编译时异常

    在程序编译期间发生的异常，称为编译时异常，也称为受检查异常(Checked Exception)

    代码示例：

    package demo2;

public class Person {
    private String name;
    private String gender;
    int age;

    public Person clone() {
        return (Person) super.clone();
    }

    public static void main(String[] args) {
        Person p = new Person();
    }
}

//编译时异常
java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出

  2. 运行时异常

    在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception)

    常见的有：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException

注：

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

2.异常的处理

2.1 异常的抛出

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

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

代码示例：

package demo3;

public class Test1 {

    public static int getElement(int[] array,int index) {
        if (array == null) {
            throw new NullPointerException("传递的数组为null");
        }

        if (index < 0 || index >= array.length) {
            throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
        }

        return array[index];
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        getElement(arr,100);
    }

}

//执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 传递的数组下标越界

在这里插入图片描述

注：

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

2.2 异常的捕获

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

2.2.1 异常声明throws

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

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

代码示例：

package demo2;

public class Person {
    private String name;
    private String gender;
    int age;

    public Person clone() throws CloneNotSupportedException { //提醒调用者处理该异常
        return (Person) super.clone();
    }

    public static void main(String[] args) {
        Person p = new Person();
    }
}

//程序正常执行不会报错

在这里插入图片描述

注：

  1. throws 必须跟在方法的参数列表之后
  2. 声明的异常必须是Exception或者Exception的子类
  3. 方法内部如果抛出了多个异常，thorws之后必须跟多个异常类型，直接用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可
  4. 调用声明抛出异常的方法是，调用者必须对该异常进行处理，或者继续使用throws抛出
2.2.2 try-catch捕获处理

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

语法格式：

try {
	//将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e) {
	//如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类时，就会被捕获到
    //对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后续代码
}finally {
    //此处代码一定会被执行到
}

代码示例：

package demo3;

public class Test2 {
    public static void main(String[] args) {

        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[100]);
            System.out.println("aa"); // 这里不会被执行
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("此处数组越界异常");
        }
        finally {
            System.out.println("Hello!!"); // 这里一定会被执行
        }
    }
}

//执行结果
此处数组越界异常
Hello!!

在这里插入图片描述

注：

  1. try内抛出异常位置之后的代码不会被执行

  2. 如果抛出异常类型与catch中的异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序(异常是按照类来捕获的)

    package demo3;

public class Test2 {
    public static void main(String[] args) {

        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[100]); //数组越界
            System.out.println("aa"); // 这里不会被执行
        }catch (NullPointerException e) { //此处数组越界异常被改为空指针异常，使得catch无法捕获到try中的异常
            System.out.println("此处数组越界异常");
        }
        finally {
            System.out.println("Hello!!"); // 这里一定会被执行
        }
    }
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

    在这里插入图片描述

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

    package demo3;

public class Test2 {
    public static void main(String[] args) {

        try {
            int[] arr = {1, 2, 3};
            int[] arr1 = null;
            System.out.println(arr[100]);
            System.out.println(arr1[0]); //这里不会被执行
            System.out.println("aa"); // 这里不会被执行
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("此处数组越界异常");
        }catch (NullPointerException e) {
            System.out.println("此处空指针异常");
        }
        finally {
            System.out.println("Hello!!"); // 这里一定会被执行
        }
    }
}

//执行结果
此处数组越界异常
Hello!!

    如果多个异常的处理方式完全相同，也可以写成这样：

    catch (ArrayIndexOutOfBoundsException|NullPointerException e) {
    //...
}

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

    package demo3;

public class Test2 {
    public static void main(String[] args) {

        try {
//            int[] arr = {1, 2, 3};
            int[] arr1 = null;
//            System.out.println(arr[100]);
            System.out.println(arr1[0]); 
            System.out.println("aa"); 
        }catch (Exception e) { //Exception 可以捕获到所有异常
            System.out.println("此处数组越界异常");
        }catch (NullPointerException e) {
            System.out.println("此处空指针异常");
        }
        finally {
            System.out.println("Hello!!"); // 这里一定会被执行
        }
    }
}

//执行结果
java: 已捕获到异常错误java.lang.NullPointerException

    在这里插入图片描述

    注：由于Exception类是所有异常类的父类，因此可以用这个类型表示捕捉所有异常

2.2.3 finally

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

语法格式：

try{
	//可能会发生异常的代码
}catch{
	//对捕获到的异常进行处理
}finally {
	//此处的语句无论是否发生异常，都会被执行到
}

//如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

代码示例：

package demo4;

public class Test1 {
    public static void main(String[] args) {

        try {
            int[] arr = {1,2,3};
            System.out.println(arr[100]);
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界溢出");
        }finally {
            System.out.println("这里一定会被执行Hello！！");
        }

        System.out.println("Hello World");
    }
}

//执行结果
数组越界溢出
这里一定会被执行Hello！！
Hello World

在这里插入图片描述

2.3 异常的处理流程

关于“调用栈”

方法之间是存在相互调用关系的，这种调用关系我们可以用“调用栈”来描述，在JVM中有一块内存空间称为“虚拟机栈”，专门用来存储方法之间的调用关系。当代码中出现异常的时候，我们就可以使用e.printStackTrace();的方式查看出现异常代码的调用栈

如果本方法中没有合适的处理异常的方式，就会沿着调用栈向上传递

代码示例：

package demo4;

public class Test2 {
    public static void main(String[] args) {
        try {
            func();
        }catch(ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }

    public static void func() {
        int[] arr = {1,2,3};
        System.out.println(arr[100]);
    }
}

//执行结果
java.lang.ArrayIndexOutOfBoundsException: 100
	at demo4.Test2.func(Test2.java:15)
	at demo4.Test2.main(Test2.java:6)
after try catch

如果向上一直传递都没有合适的方法处理异常，最终就会交给JVM处理，程序就会异常终止(和我们最开始未使用try-catch时是一样的)

package demo4;

public class Test2 {
    public static void main(String[] args) {
    	func();
        System.out.println("after try catch");
    }

    public static void func() {
        int[] arr = {1,2,3};
        System.out.println(arr[100]);
    }
}

//执行结果
java.lang.ArrayIndexOutOfBoundsException: 100
	at demo4.Test2.func(Test2.java:15)
	at demo4.Test2.main(Test2.java:6)
after try catch

可以看到，程序已经异常终止了，没有执行到 System.out.println("after try catch");这一行

【异常处理流程总结】

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

3.自定义异常类

Java中虽然已经内置了丰富的异常类，但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构

例如，我们实现一个用户登录功能：

package demo5;

public class Login {

    private String userName = "XiaoMa";
    private String passWord = "11111";

    public static void loginInfo(String userName, String passWord) {
        if (!userName.equals(userName)) {

        }

        if (!passWord.equals(passWord)) {

        }

        System.out.println("登陆成功！！");

    }
    public static void main(String[] args) {
        loginInfo("XiaoMa","11111");
    }

}

此时我们在处理用户名密码错误的时候可能就需要抛出两种异常，我们可以基于已有的异常类进行扩展(继承)，创建和我们业务相关的异常类

具体方式：

  1. 自定义异常类，然后继承Exception或者RunTimeException
  2. 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因
class UserNameException extends Exception {
    public UserNameException(String message) {
        super(message);
    }
}

class PassWordException extends Exception {
    public PassWordException(String message) {
        super(message);
    }
}

此时我们的login代码可以改成:

package demo5;

public class Login {

    public static String userName = "XiaoMa";
    private static String passWord = "11111";

    public static void loginInfo(String username, String password) throws UserNameException, PassWordException {
        if (!userName.equals(username)) {
            throw new UserNameException("用户名错误");
        }

        if (!passWord.equals(password)) {
            throw new PassWordException("密码错误");
        }

        System.out.println("登陆成功！！");

    }

    public static void main(String[] args) throws UserNameException, PassWordException {
        try {
            loginInfo("Xiao","11111");
        }catch (UserNameException e) {
            e.printStackTrace();
        }catch (PassWordException e) {
            e.printStackTrace();
        }
    }

}

class UserNameException extends Exception {
    public UserNameException(String message) {
        super(message);
    }
}

class PassWordException extends Exception {
    public PassWordException(String message) {
        super(message);
    }
}

//执行结果
demo5.UserNameException: 用户名错误
	at demo5.Login.loginInfo(Login.java:10)
	at demo5.Login.main(Login.java:23)

在这里插入图片描述

注：

  • 自定义异常通常会继承自Exception||RuntimeException
  • 继承自Exception的异常默认是受查异常
  • 继承自RunTimeException的异常默认是非受查异常
&梧桐树夏
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE 异常和处理
m0_61905617的博客
05-09 1341
异常和处理的五个关键字：throw,throws, try, catch,finally其中try和catch是配套的，且finally也是必须和try一起使用的，finally的作用用于资源释放和回收和不管异常没有，都会执行finally里面的代码，throw是必须要在方法中创建的,且throw关键字后边必须是exception和他的的子类。因为以前没有泛型，且所有的都是Object的集合，该集合可以存储任何类型的数据，所以就必须要明确每个object的类型。不同的数据结构，存储数据的方式不同。
JavaSE异常
zhangshuai66的博客
07-28 686
JavaSE异常学习
JavaSE异常练习
weixin_51985152的博客
02-13 193
异常实验要求实验过程 实验要求 1、运行时异常与一般异常有何异同 2、Java中的异常处理机制的简单原理和应用 3、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？ 4、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后? 5、error和exception有什么区别。 实验过程 1、运行时异常与一般异常有何异同  
javase 异常
be_lxx1的博客
01-10 195
受检异常：在编译过程中 非受检异常：在运行过程中 使用 try{}语句块把可能出现异常的语句块包裹起来 catch可以采取多个； 异常处理的三个关键字try/catch/finally确保了程序出现异常后不会报错而终止程序，让程序可以正常的继续运行直到结束。 catch小技巧：范围小的放在前面，范围大的放在后面 finally是进行异常处理之后，在异常的处理格式，作为异常的统一出口，不管是否产生了异常，最终都执行该代码。 代码测试时可以使用。printStackTrace（） t..
JavaSE异常捕获
smart_lhp的博客
01-25 105
一般Java中异常捕获使用try-catch-finally。try为监控区域，catch（想要捕获的异常类型）来捕获异常，finally来处理善后，比如io资源关闭，可以没有finally。如果要捕获多个异常，则从上到下按照从小到大捕获。throw和throws用来抛出异常，throw用在方法中，主动抛出异常，throws则写在方法上，方法上抛出异常。 public static void main(String[] args) { int a = 1; ...
JavaSE 异常作业
技术小白
02-12 349
1、运行时异常与一般异常有何异同 异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。 一般异常：java编译器强制要求我们必需对出现的异常进行try…catch…处理的否则程序不能通过编译 2、Java中的异常处理机制的简单原理和应用 Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得 程序简洁
JavaSE 异常实践
Black_Cat_33的博客
03-27 150
作业： 编写程序模拟用户注册： 程序开始执行时，提示用户输入“用户名”和“密码”信息 输入信息之后，后台Java程序模拟用户注册 注册时用户名要求长度在[6-14]之间，小于或大于都表示异常 完成注册的方法放到一个单独的类中，异常类自定义即可 class UserService{ public void register(String userName,String password){ 这个方法中完成注册！ } } 编写main方法，在main方法中接收用户输入的信息，在main方法中调
JavaSE之异常
weixin_47543906的博客
11-09 233
编译时异常 直接继承Exception,也叫检查时异常 在编译时期就必须处理，否则编译失败，程序无法运行。 （如日期格式化异常ParseException）
JavaSe异常02：捕获和抛出异常（笔记）
qq_39469977的博客
08-21 118
视频学习地址 点我跳转ψ(｀∇´)ψ 前言 通俗来说就是捕捉到错误，可以自定义异常并输出，最后关闭一些资源。 处理异常的五个关键字 try：尝试 catch：捕获 finally：善后 throw：方法体抛出异常 throws：方法上抛出异常 public class Application { public static void main(String[] args) { try { //try监控区域 //System.out.println
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
Javase 异常思维导图
06-04
异常思维导图
JavaSE 异常处理.pdf
07-23
Java异常处理是编程中至关重要的一个方面，它允许开发者在程序遇到错误或异常情况时进行控制，确保程序的稳定性和健壮性。Java的异常处理机制由五个关键字组成：`try`、`catch`、`finally`、`throw` 和 `throws`。在...
王道JavaSE阶段测试
05-31
JavaSE是Java开发的基础，包括但不限于类与对象、封装、继承、多态、异常处理、集合框架、IO流、线程、网络编程等内容。这份文档可能包含了这些主题的相关习题、案例分析或者知识点总结。 【压缩包子文件的文件名称...
JavaSE笔记11111
10-15
JavaSE是Java标准版，是Java编程的基础，涵盖了面向对象编程、集合框架、I/O流、多线程和反射等多个核心知识点。 面向对象是Java的核心...在实际开发中，还需要理解异常处理、集合高级特性和设计模式等更复杂的概念。
配置Java开发环境
Broken_x的博客
07-10 1576
Java开发环境配置
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 283
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
elk部署springboot
Chihirozy的博客
07-11 394
elk部署springboot。
基于Java技术的校园台球厅人员与设备管理系统
最新发布
heye0910032的博客
07-12 534
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值