JavaSE入门---关于异常那些事儿

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

文章目录

什么是异常？

在Java中，将程序执行过程中出现的不正常行为称为异常。比如：

		//算术异常
        System.out.println(10/0);
        //输出：Exception in thread "main" java.lang.ArithmeticException: / by zero

        //数组越界异常
        int[] arr = {1,2,3};
        System.out.println(arr[10]);
        //输出：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10

        //空指针异常
        int[] array = null;
        System.out.println(array.length);
        //输出：Exception in thread "main" java.lang.NullPointerException

异常的体系结构

异常在Java中以类的形式出现，每一个异常类都可以创建异常对象。异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：

在这里插入图片描述

注：

  1. throwable是异常体系的顶层类，其派生出两个重要子类error类和exception类；
  2. error类：指JVM无法解决的严重问题，如：JVM的内部错误、资源耗尽等；
  3. exception类：指异常产生后程序员可以通过代码进行处理，使程序继续执行的问题；

异常的分类

可以将异常分为：

  1. 编译时异常，也称为 受检查异常，要求程序员在编写程序阶段必须预先对这些异常进行处理，如果不处理编译器报错；
    编译时异常是在编译阶段发生的吗？
    不是。是在编写程序的时候发生
  2. 运行时异常，也称为 非受检查异常，在编写程序阶段程序员可以预先处理，也可以不管，都行。；

在这里插入图片描述

注：

  1. 异常分为编译时异常和运行时异常，但所有异常都是在运行阶段发生的，因为，只有运行阶段才可以new对象，异常的发生就是new异常对象。
  2. 编译时异常一般发生的概率比较高，需要在运行之前进行预处理；运行时异常一般发生的概率比较低，在运行之前不必进行预处理。

一个异常的完整执行流程

	 public static void main(String[] args) {
        System.out.println(10/0);

        //这里的hello world 没有执行
        System.out.println("hello world");
    }

流程：

  1. 程序执行到System.out.println(10/0),发生了ArithmeticException算术异常，底层new了一个ArithmeticException异常对象，然后抛出了
  2. 由于是main方法调用了10/0，所以这个ArithmeticException抛给了main方法，但main方法没有处理，又会把这个异常抛给JVM
  3. JVM中止程序的执行，此时，System.out.println(“hello world”)不会执行。

异常的处理

防御式编程

  • LAYL：Look Before You Leap，操作之前就做充分的检查，即事前防御型
boolean ret = false;
        ret = 登录游戏();
        if (!ret){
            处理登录游戏异常;
            return;
        }

        ret = 开始匹配();
        if (!ret){
            处理开始匹配异常;
            return;
        }

        ret = 游戏确认();
        if (!ret){
            处理游戏确认异常;
            return;
        }

        ret = 载入游戏画面();
        if (!ret){
            处理载入游戏画面异常;
            return;
        }
        .....

缺点：正常代码和错误代码流程放在一起，代码整体显的比较混乱。

  • EAFP：It‘s Easier to Ask Forgiveness than Permission 事后获取原谅比事前获取许可更容易，也就是先操作，遇到问题再处理；即事后认错型。
	try {
            登陆游戏();
            开始匹配();
            游戏确认();
            载入游戏画面();
            ...
        } catch (登陆游戏异常) {
            处理登陆游戏异常;
        } catch (开始匹配异常) {
            处理开始匹配异常;
        } catch (游戏确认异常) {
            处理游戏确认异常;
        } catch (载入游戏画面异常) {
            处理载入游戏画面异常;
        }
        ......

优势：正常流程和错误流程是分离开的，程序员更关注正常流程，代码更清晰，更容易理解。

所以，我们在处理异常时的核心思想就是 EAFP，我们需要明白“异常一旦出现是必须要被处理了才能继续执行后面的代码的”，处理异常可以交给JVM处理：直接中止程序执行；交给用户自己处理：可以按照自己的意愿来进行合适的处理，再执行后面的代码；

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

异常的声明

在编写程序时，如果程序中出现错误，此时就需要把错误的信息告诉调用者；

在Java中，可以通过throw关键字，来声明一个指定的异常对象，将错误的信息告诉调用者。但是它不会处理异常，必须搭配throws或者try-catch来使用。

用throw声明异常后会自动抛出

由方法的调用者使用throws配合使用：上报给上一级，直到交给JVM处理程序直接中止，不会执行后面的代码；
由方法的调用者使用try-catch配合使用：用户自己处理，处理之后可以继续执行后面的代码；

	public static int getElement(int[] arr,int index){
        if (arr == null){
            //通过throw 告诉调用者出现的异常情况信息
            throw new NullPointerException("传递的数组为空");
        }

        if (index < 0 || index >= arr.length){
            //通过throw 告诉调用者出现的异常情况信息
            throw new ArrayIndexOutOfBoundsException("要访问的数组下标越界");
        }
        
        return arr[index];
    }

    //实现一个获取数组指定位置元素的方法
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int ret = getElement(arr,2);
        System.out.println(ret);
    }

注：

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

异常的捕获

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

异常声明throws

当方法中抛出编译时异常（使用throws抛出异常后必须有人来进行处理），用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者处理。即当前方法不处理异常，提醒方法的调用者处理异常，如果方法的调用者也不处理，则会交给JVM处理，程序直接中止运行。

  • 方法抛出异常后，方法的调用者不处理，继续向上级抛出异常，直到让JVM处理：程序中止。不执行后面的代码。
	public static int getElement(int[] arr,int index) throws ArrayIndexOutOfBoundsException{
        return arr[index];
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException{
        int[] arr = {1,2,3};
        int ret = getElement(arr,3);

        System.out.println("执行后面的代码");
    }

//会打印出异常日志   但不会打印出   执行后面的代码
  • 方法抛出异常后，方法的调用者使用try-catch处理异常。会执行后面的代码。
	public static int getElement(int[] arr,int index) throws ArrayIndexOutOfBoundsException{
        return arr[index];
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            int ret = getElement(arr,3);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }

        System.out.println("执行后面的代码");
    }

//会打印出异常日志 和 执行后面的代码

注：

  1. 只要异常没有捕捉，采用上报的方式，此方法的后续代码不会执行。就像上面说的第一种解决方法
  2. try-catch捕捉异常后，后续代码可以执行。就像上面说的第二种解决方法。
  3. try语句块中的某一行出现异常，该行后面的代码不会执行
public static int getElement(int[] arr,int index) throws ArrayIndexOutOfBoundsException{
        return arr[index];
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            int ret = getElement(arr,3);
            //下面的代码不会执行
            System.out.println("getElement之后的语句");
            System.out.println("getElement之后的语句");
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }

        //这里的代码还会执行
        System.out.println("执行后面的代码");
    }

//会打印出异常日志 和 执行后面的代码

try-catch捕获并处理

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

	public static int getElement(int[] arr,int index) throws ArrayIndexOutOfBoundsException{
        return arr[index];
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            int ret = getElement(arr,3);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }

        System.out.println("执行后面的代码");
    }

注：

  1. catch（）里的 e ，表示是e引用，保存的地址是那个new出来的异常对象的地址；
  2. try中可能会抛出多个异常，则建议使用多个catch来一对一精确捕获；
  3. catch中捕获的异常类型既可以是具体的异常类型，也可以是该异常类型的父类型。
  4. catch中捕获多个异常时，从上到下，必须遵守异常的范围从小到大。否则先捕获到该类的父类型时，就不会继续向下检测，不会捕获到具体的异常类型了。
ArrayIndexOutOfBoundsException,NullPointerException{
        return arr[index];
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            int ret = getElement(arr,1);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }catch (NullPointerException e){
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }
    } ```

5. catch捕获多个异常时，异常间可以用 | 分割

```java 	public static int getElement(int[] arr, int index) throws
ArrayIndexOutOfBoundsException,NullPointerException{
        return arr[index];
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            int ret = getElement(arr,1);
        }catch (ArrayIndexOutOfBoundsException  | NullPointerException | Exception){
            System.out.println("出现异常");
        }
    } ```

finally

在某些特定的代码中，我们必须要求其释放持有的资源，比如文件读取等，但是当遇到异常时，它下面的一些代码就不会被执行到，这样就会引发一些问题。因此，我们使用finall来解决这个问题。

finall子句必须和try一起出现，不能单独编写。
即使try语句块中的代码出现了异常，finall中的代码也是一定会执行的。

	public static void main(String[] args) {
        try {
            System.out.println("try");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("finally");
        }
    }

注：

  1. try和finally联用，没有catch；
        try {
            System.out.println("try");
            return;
        } finally {
            System.out.println("finally");
        }
    } ```

2. 如果try语句块中有return，那么try、finally、return的执行顺序是怎样的？

   先执行try、再执行finally、最后执行return；finally执行的时机是在return以前。

3. 如何让finally失效呢？ System.exit()

```	public static void main(String[] args) {
        try {
            System.out.println("try");
            //退出JVM 退出之后finally中的语句就不执行了
            System.exit(0);
        } finally {
            System.out.println("finally");
        }
    } ```

4. 一般在finally中进行一些资源清理的工作。

异常的处理流程

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

自定义异常类

Java中，虽然已经内置了丰富的异常类，但是并不能完全表示在实际开发中遇到的所有异常，此时就需要我们自己定义异常。

自定义异常有两步：

  1. 编写一个类，继承Exception或者RuntimeException。
  2. 提供两个构造方法，一个无参，一个带有String参数。

下面以登录为例，演示自定义异常类的使用。

//自定义用户名错误类
class UsernameFalseException extends Exception{
    public UsernameFalseException(){

    }

    public UsernameFalseException(String msg){
        super(msg);
        System.out.println(msg);
    }
}

//自定义密码错误类
class PasswordFalseException extends Exception{
    public PasswordFalseException(){

    }

    public PasswordFalseException(String msg){
        super(msg);
        System.out.println(msg);
    }
}

public class Test {
    private static String USER_NAME = "admin";
    private static String PASS_WORD = "123456";


    public static void login(String username,String password) throws UsernameFalseException, PasswordFalseException {
        if (!username.equals(USER_NAME)){
            throw new UsernameFalseException("用户名错误");
        }

        if (!password.equals(PASS_WORD)){
            throw new PasswordFalseException("密码错误");
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String username = scanner.nextLine();
        String password = scanner.nextLine();

        try {
            login(username,password);
            System.out.println("登录成功");
        }catch (UsernameFalseException e){
            e.printStackTrace();
        }catch (PasswordFalseException e){
            e.printStackTrace();
        }
    }
}
Yumpie_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE原理-日期类API导学.md
02-19
JavaSE原理-日期类API导学.md
javase-学习笔记.pdf
11-28
javase-学习笔记.pdf
JavaSE基础之------------多线程
LBJ_小松鼠的博客
11-14 95
1.实现多线程 进程和线程【理解】 进程：是正在运行的程序 ​ 是系统进行资源分配和调用的独立单位 ​ 每一个进程都有它自己的内存空间和系统资源 线程：是进程中的单个顺序控制流，是一条执行路径 ​ 单线程：一个进程如果只有一条执行路径，则称为单线程程序 ​ 多线程：一个进程如果有多条执行路径，则称为多线程程序 实现多线程方式一：继承Thread类【应用】 方法介绍 方法名 说明 void run() 在线程开启后，此方法将被调用执行 void start() 使此线程开始
【JavaSE】Cloneable？关于深拷贝与浅拷贝那些事儿咱们一次聊明白
黄小黄的博客
12-28 553
什么是深拷贝，什么是浅拷贝？Java中又该如何实现对象的拷贝呢？这篇文章，深浅拷贝区别与实现一次给你聊明白！
编程开发进阶--收藏
laiwenqiang的专栏
12-12 1510
转载于：http://www.iteye.com/magazines/130 博客是记录学习历程、分享经验的最佳平台，多年以来，各路技术大牛在ITeye网站上产生了大量优质的技术文章，并将系列文章集结成专栏，以便读者能够更便捷、更系统地浏览学习，这些可称之为“编程精华资源”。 为了便于读者更好地查阅，本文将ITeye中的这些精华资源进行了整理分类，你可以通过文中链接跳转到相应的专栏，希
Java基础教程-01-Java简介与变量介绍
kc44601的博客
04-03 984
Java基础教程-01-Java简介与 1. 计算机基本概念 1.1 计算机组成 计算机由计算机硬件和计算机软件组成. 计算机硬件: 你的眼睛能看的见, 你的手能摸得着的东西. 1)中央处理器(CPU) • 由运算器和控制器组成. 2)存储器 • 内存: 内存条(代数, 睿频). • 外存: 硬盘(SSD: 固态硬盘, HSD: 混合盘, HDD: 机械硬盘), U盘. 3)输入设备 • 键盘, 鼠标 4)输出设备 • 显示器. 计算机软件: 能在计算机上运行的程序. 1)系统软件: Windows操
java入门经典 视频_新手Java基础入门经典教程！（附视频+课件）
weixin_39535349的博客
02-16 315
在大家看之前，我要先声明两点。1、由于我本人是Java后端开发出身，因此所推荐的学习内容是Java Web和Java后端开发的路线，非Java Web和Java后端开发的同学请适当参考其学习思想即可，切勿照搬。第一部分主要是JavaSE基础，后续还有Java Web、框架等主要是想通过这个平台把自己的学习历程和一些收获总结给系统的梳理一下，同时也可以帮助一些想从事java开发的同学，欢迎大家讨论，...
今天我们谈谈关于java自学的那些事儿(为那些目标模糊的码农们)
hello world！
04-09 491
文章写得有点长，还请大家耐心看完 ! JAVA自学之路 一:学会选择 为了就业，不少同学参加各种各样的培训。 决心做软件的，大多数人选的是java，或是.net，也有一些选择了手机、嵌入式、游戏、3G、测试等。 那么究竟应该选择什么方向呢？ 我的意见是，不要太过相信各种培训机构或是抢手文章的说法（包括我），当你要走向社会的时候，就不要再把自己当成学生，不要把自己的将来交给别人，学会运用自...
学Java 这样入门 28天轻松掌握
LSFZ88888的博客
07-30 225
学习Java如何才算是入门，这是很多初学者要接触的第一个知识上的瓶颈，Java如何学习、学习到那一步才能够成功继续往下走。 万事开头难编程入门更是如此，编程入门我们了解语言的体系，锻炼自己的编程思维方式，牢记编程式英语等等。 学习Java是一件比较无聊的阶段，每天的都要面对的是一堆堆陌生的代码、语句和判断，所以学习编程重要的是坚持不懈的学习。首先 声明Java语言学习起来是比较难的，虽然去掉啦C++里面一些恼人特性，但是对于一门编程语言的来说只是提高啦你对一门语言能学下去的动力。Java编程语言整体来讲
编程精华资源（ITeye优秀专栏）大汇总
热门推荐
好学若饥，谦卑若愚
05-12 1万+
博客是记录学习历程、分享经验的最佳平台，多年以来，各路技术大牛在ITeye网站上产生了大量优质的技术文章，并将系列文章集结成专栏，以便读者能够更便捷、更系统地浏览学习，这些可称之为“编程精华资源”。 为了便于读者更好地查阅，本文将ITeye中的这些精华资源进行了整理分类，你可以通过文中链接跳转到相应的专栏，希望技术大牛们的这些不可多得的经验分享，能够为你的技术学习、开发之路带来一些帮助。在此首...
java面试常见知识点
天行健，君子以自强不息；地势坤，君子以厚德载物。
02-15 676
阅读文本大概需要30分钟。一、JVM1. JDK、JRE、JVM三者间的关系JDK（Java Development Kit）是Java开发工具包，是整个JAVA的核心，包括了Java运...
JavaSE专题-Set集合.doc
06-03
JavaSE专题-Set集合
javase-2.0.jar
04-21
使用java在服务端进行aes的加密解密，前端使用该js进行aes加密解密；
JavaSE--思维导图解析
07-26
JavaSE--思维导图解析
从需求角度介绍PasteSpider(K8S平替部署工具适合于任何开发语言)
05-14 1120
Kubernetes的强大毋庸置疑，但是你有问自己这么个大杀器真的适合你么？这里推荐一款更加小巧的容器部署工具，集报表，发布，环境，通知于一身的PasteSpider! 支持git/svn发布，支持平滑升级，支持环境隔离，支持用户隔离，支持运行变量设定等，关键易上手！
jar包增量更新分析
junlaiyan的专栏
05-16 314
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 674
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 151
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
javase篇-第07讲--面向对象1
09-08
在JavaSE中，我们可以通过封装、继承和多态来实现面向对象编程的目标。封装可以提高程序的可维护性和可复用性，继承可以减少重复编码的工作量，多态可以灵活地操作对象。掌握这些基本概念和关键术语，可以帮助我们更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值