Java异常处理

最新推荐文章于 2023-01-11 20:53:14 发布
最新推荐文章于 2023-01-11 20:53:14 发布
阅读量400 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XC13546508094/article/details/125929105
版权

【一】异常_异常的案例引入

代码：

public class Test {
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数，求商；
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入第一个数：");
        int numl=sc.nextInt();
        System.out.println("请录入第二个数：");
        int num2=sc.nextInt();
        System.out.println("商："+numl/num2);
    }
}

结果：
在这里插入图片描述
测试过程中发现问题：
录入的数据应为int类型，但是录入非int类型数据的时候，出异常。
在这里插入图片描述
除数为0的时候
在这里插入图片描述
异常： Exception：在程序的运行过程中，发生了不正常的现象，阻止了程序的运行，我们称之为发生异常

【二】异常_用if_else处理异常

public class Test {
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数，求商；
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入第一个数：");
        if(sc.hasNextInt()){
            int numl=sc.nextInt();
            System.out.println("请录入第二个数：");
            if(sc.hasNextInt()){
                int num2=sc.nextInt();
                if(num2==0){
                    System.out.println("对不起除数不能为0");
                }else{
                    System.out.println("商："+numl/num2);
                }
            }
        }else{
            System.out.println("对不起，你录入的不是int类型的数！");
        }
    }
}

用if_else堵漏洞的缺点：
（1）代码臃肿，业务代码和处理异常的代码混在一起。
（2）可读性差。
（3）程序员需要花费大量的精力来维护这个漏洞。
（4）程序员很难堵住所有的漏洞。

【三】异常_try-catch捕获异常

【1】基于if_else处理异常缺点太多，所有Java中专门出了一个异常处理机制：
”异常三连“try-catch-finally
【2】异常出现了以后怎样看：
在这里插入图片描述
【3】捕获异常：try-catch

public class Test2 {
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数，求商：
        try{
            Scanner sc=new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int numl=sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2=sc.nextInt();
            System.out.println("商："+numl/num2);
        }catch (Exception ex){
            System.out.println("对不起你的程序异常了！");
        }
        System.out.println("谢谢使用计算器！");
    }
}

原理：
把可能出现异常的代码放入try代码块中，然后将异常封装为对象，被catch 后面的( )中的那个异常对象接收，接受以后：执行catch后面的{ }里面的代码，然后try-catch后面的代码，该怎么执行就怎么执行。
详细说一下：
（1）try中没有异常，catch中代码不执行。
（2）try中有异常，catch进行捕获。
如果catch中异常类型和你出的异常类型匹配的话：走catch中的代码–》进行捕获
如果catch中异常类型和你出的异常类型不匹配的话：不走catch中的代码–》没有捕获成功，程序相当于遇到异常了，中断了，后续代码不执行，

注意：
（1）try中如果出现异常，然后用catch捕获成功的话，那么try中后续的代码时不会执行的
（2）如果catch捕获异常成功，那么try-catch后面的代码该执行还是执行没有影响。
catch处理异常的四种方式：

public class Test3 {
        public static void main(String[] args) {
            //实现一个功能：键盘录入两个数，求商：
            try{
                Scanner sc=new Scanner(System.in);
                System.out.println("请录入第一个数：");
                int numl=sc.nextInt();
                System.out.println("请录入第二个数：");
                int num2=sc.nextInt();
                System.out.println("商："+numl/num2);
            }catch (Exception ex){
                //第一种处理：什么都不写，什么都不做

                //第二种处理：输出自定义异常信息
//                System.out.println("对不起你的程序异常了！");

                //第三种处理：打印异常信息：
                /*
                (1)调用toString方法，显示异常的类名(全限定路径)
                 */
//                System.out.println(ex.toString());
                /*
                (2)显示异常描述信息对应的字符串，如果没有就显示null
                 */
//                System.out.println(ex.getMessage());
                /*
                (3)显示异常的堆栈信息：将异常信息捕获以后，在控制台将异常的效果给我们展示出来，方便我们查看异常
                 */
//                ex.printStackTrace();
                //第四种处理：抛出异常
                throw ex;
            }
            System.out.println("谢谢使用计算器！");
        }
}

【四】异常_finally

【1】在什么情况下，try_catch后面的代码不执行？
（1）throw抛出异常的情况
（2）catch中没有正常的进行异常捕获
（3）在try中遇到return
【2】怎么样才可以将try_catch后面的代码 必须执行？
只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行。
【3】return和finally执行顺序？
先执行finally，最后执行return
【4】什么代码会放在finally中呐？
关闭数据库资源，关闭IO流资源，关闭socket资源。
【5】有一句代码很厉害，它可以让finally中代码不执行！

System.exit(0);//终止当前的虚拟机执行

代码：

public class Test3 {
        public static void main(String[] args) {
            //实现一个功能：键盘录入两个数，求商：
            try{
                Scanner sc=new Scanner(System.in);
                System.out.println("请录入第一个数：");
                int numl=sc.nextInt();
                System.out.println("请录入第二个数：");
                int num2=sc.nextInt();
                System.out.println("商："+numl/num2);

            }catch (Exception ex){
                //throw ex;
                System.exit(0);//终止当前的虚拟机执行
                return ;
            }finally {
                System.out.println("谢谢使用计算器！");
            }
        }
}

【五】异常_多重catch

【1】try中出现异常以后，将异常类型跟catch后面的类型依次比较，按照代码的顺序进行比对，执行第一个与异常类类型匹配的catch比较。
【2】一旦执行其中一条catch语句之后，后面的catch语句就会被忽略。
【3】在安排catch语句的顺序的时候，一般会将特殊异常放在前面(并列)，一般化的异常放在后面。
先写子类异常，再写父类异常。
【4】在JDK1.7之后，异常新处理方式：可以并列用　｜　符号连接：
Ctrl+B 进入源码查看
在这里插入图片描述
代码：

public class Test4 {
        public static void main(String[] args) {
            //实现一个功能：键盘录入两个数，求商：
            try{
                Scanner sc=new Scanner(System.in);
                System.out.println("请录入第一个数：");
                int numl=sc.nextInt();
                System.out.println("请录入第二个数：");
                int num2=sc.nextInt();
                System.out.println("商："+numl/num2);

            }catch (InputMismatchException ex){
                System.out.println("对不起，你录入的数据不是int类型的数据！");
            }catch(ArithmeticException ex){
                System.out.println("对不起，除数不可以为0");
            }catch(Exception ex){
                System.out.println("对不起，你的程序出现异常！");
            }
            finally {
                System.out.println("谢谢使用计算器！");
            }
        }
}

【六】异常_异常的分类，层次结构

【1】层次结构
在这里插入图片描述
注意：程序中语法错误，逻辑错误 都不属于Error，Exception
【2】运行时异常

public class Test5 {
    public static void main(String[] args) {
        //运行时异常：
        int []arr={1,2,3};
        System.out.println(arr.length);
        /*int []arr2=null;
        System.out.println(arr2.length);*/
    }
}

【3】检查异常 Alt+Enter
（1）处理方式1：try-catch嵌套try-catch

public class Test6 {
    public static void main(String[] args) {
        //检查异常
        try {
            try {
                Class.forName("aaaaaa").newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

（2）处理方式2:多重catch

public class Test6 {
    public static void main(String[] args) {
        //检查异常
        try {
            Class.forName("aaaaaa").newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

（3）处理方式3：throws

public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException {
        //检查异常
        
            Class.forName("aaaaaa");
    }
}

【七】异常_throw和throws的区别

代码：

public class Test7 {
    public static void main(String[] args) throws Exception {
        //实现一个功能：两个数相除，当除数为0的时候，程序出现异常
        devide();
    }
    public static void devide() throws Exception {
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入第一个数：");
        int numl=sc.nextInt();
        System.out.println("请录入第二个数：");
        int num2=sc.nextInt();
        if(num2==0){  //除数为0，制造异常
            //制造运行时异常
//            throw new RuntimeException();
            //制造检查异常
            /*try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }*/
            throw new Exception();     
        }else{
            System.out.println("商："+numl/num2);
        }
    }
}

总结：
throw和 throws的区别：
（1）位置不同：
throw：方法内部
throws：方法的签名处，方法的声明处

（2）内容不同：
throw+异常对象（检查异常，运行时异常）
throws+异常的类型（可以多个类型，用，连接）

（3）作用不同：
throw：异常出现的源头，制造异常
throws：在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常
，然后调用者对这个异常进行处理：要么自己处理要么再继续向外抛出异常。
代码：

public class Student {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) throws Exception {
        if(sex.equals("男")||sex.equals("女")){
            this.sex = sex;
        }else{//非男非女
            //解决方法1：
            /*this.sex="男";*/
            //解决办法2：给个友好性提示，但是打印结果为默认的null效果
            System.out.println("对不起，你的性别错误了！");
            //解决办法3：
            //制造运行时异常
            //throw new RuntimeException("性别不对！");
            //制造检查时异常：
            /*try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }*/
            throw new Exception();
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }

    public Student() {
    }

    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        try {
            this.setSex(sex);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Test {
            public static void main(String[] args) throws Exception {
                //创建一个Student对象
                Student s=new Student();
                s.setName("平平");
                s.setAge(18);
        s.setSex("女");
        System.out.println(s);

        Student s2=new Student("朋友",18,"女");
        System.out.println(s2);
    }
}

【八】异常_重载和重写异常的区别

【1】重载：

public class Demo {
    public void A() throws Exception{
        
    }
    public void A(int age) throws ArithmeticException{
        
    }
}

【2】重写：
在这里插入图片描述
在这里插入图片描述
子类<=父类

【九】异常_自定义异常

代码：

public class MyException extends RuntimeException{
    static final long serialVersionUID = -70348971L;

    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

自定义的异常可以继承：运行时异常

public class MyException extends RuntimeException{
    static final long serialVersionUID = -70348971L;

    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

也可以继承检查异常：

public class MyException extends Exception{
    static final long serialVersionUID = -70348971L;

    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

如果继承的是运行时异常，那么在使用的时候无需额外处理
如果继承的时检查异常，那么使用的时候需要try_catch捕获或者throws向上抛

引用：马士兵教育珊珊老师、Java开发手册

文章目录

西CSun
关注
专栏目录
java中的异常及异常处理 ：try、catch、finally、throw、throws
maker.dong的博客
01-07 891
这里写自定义目录标题【异常】主要内容第一章 异常1.1 什么是异常1.2 异常体系1.3 异常的分类1.4 异常是如何产生的第二章 处理异常的方式2.1 抛出异常throw2.2 声明异常throws2.3 捕获异常try…catch2.4 finally 代码块2.5 Objects非空判断2.6 异常注意事项第三章 自定义异常3.1 概述3.2 自定义异常的练习 【异常...
java异常处理的简单练习
09-02
Java异常处理是编程中至关重要的一个环节，它用于在程序执行过程中处理错误和不寻常的情况。在Java中，异常处理通过使用try-catch-finally语句块和异常类来进行。以下是对给定代码的详细解释： 1. **异常类的继承**...
异常19
qq_54823276的博客
03-05 226
异常 1、处理异常方式：if-else public class Test { //这是一个main方法，是程序的入口： public static void main(String[] args) { //实现一个功能：键盘录入两个数，求商： Scanner sc = new Scanner(System.in); System.out.println("请录入第一个数："); int num1 = sc.nextInt();
异常处理
NaitoAI的博客
07-09 203
异常处理什么是异常？异常的产生到程序中断的过程：如何处理异常？try+catch的处理流程：finally：异常体系结构：throws关键字throw关键字RuntimeExcepion与Exception的区别自定义异常类（了解即可）异常处理常见面试题 什么是异常？ 异常是在程序中导致程序中断运行的一种指令流。 一旦产生异常之后，异常之后的语句将不再执行了，就会导致程序在并没有正确的执行完毕就退出了。所以，为了保证程序出现异常之后仍然可以正确的执行完毕，所以要采用异常的处理机制。 异常的产生到程序中断的过
自定义异常处理的功能实现
饮马流花河
08-07 859
这天很开心，终于把自定义异常处理的原理搞明白，还做了出来，现在做一做笔记，还可以温故知新。主要是这几个动作：1、先做个xml，用来存储异常信息。文件名：MsgsResource.xmlxml version="1.0" encoding="utf-8" ?> messages>    message id="0">        title>数据提供问题title>        body
java异常处理（四）—还在用if判断校验参数？试试SpringBoot全局异常+JSR303校验吧！
shang_0122的博客
02-28 2766
SpringBoot全局异常+JSR303校验解放if判断，更加专注于业务逻辑
详解Java异常处理中throw与throws关键字的用法区别
09-03
Java异常处理是编程中至关重要的一个环节，它帮助我们识别和修复程序运行时可能出现的问题。在Java中，异常处理主要通过try-catch-finally结构来实现，而在异常处理中，`throw` 和 `throws` 关键字起着关键作用。...
Java异常处理的最佳实践
01-27
Java异常处理是编程实践中至关重要的一个方面，它确保了程序的稳定性和健壮性。本文主要探讨了Java异常处理的最佳实践，包括理解异常的类型、何时何地使用异常，以及如何有效地处理它们。 首先，Java异常分为两种...
java异常处理
06-08
Java异常处理是编程中至关重要的一个环节，它允许程序员优雅地处理程序运行过程中可能出现的错误情况，确保程序的稳定性和健壮性。异常处理机制在Java中被设计为一种结构化的方法，使得程序在遇到不可预见的问题时，...
Java异常处理学习心得
08-28
Java 异常处理学习心得 Java 异常处理是 Java 编程语言中的一个重要概念，它允许开发者捕获和处理程序中的异常，从而确保程序的可靠性和稳定性。在 Java 中，异常处理机制可以分为两种：可控式异常和运行时异常。 ...
什么是致命异常错误
[ .::心 情 驿 站::. ]
09-24 2749
概要尝试关闭计算机、启动 Windows 或 Windows 内的程序时，可能遇到类似下面的错误消息： 在 xxxx:xxxxxxxx 位置发生了致命异常 XY致命异常错误是由程序在下列情况下返回的代码： 发生了对非法指令的访问 访问了无效的数据或代码 某个操作的权限级别无效 出现上述任何一种情况时，处理器都会向操作系统返回一个异常错误，接着，该异常错误被作为“致命异常错误
自定义异常及其原理剖析
qq_27416233的博客
06-14 349
概述 在公司写项目的时候发现,虽说我们异常采用了全文捕获的方式,这一点不是很清楚，特此梳理文章来记录下，自己学习的过程 先要会用 首先我们要思考一个问题: 它是怎么样子捕获异常的？我们都知道我们前后端交互如下图: 过程如下: 前端通过Http请求访问后端 spring项目通过web.xml配置接受前端请求的方式参考Jsp + Servlet的项目(以后有机会补上),将请求都映射到spring-mvc.xml这个文件中(一般情况下) 这个样子就完成了前端到后端的映射 在以
java异常处理概述_Java 异常处理 之 异常概述与异常体系结构
weixin_42306002的博客
02-27 268
一、异常概述1、异常在 Java 语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)指的是程序在执行过程中，出现的非正常的情况，最终会导致 JVM 的非正常停止。在 Java 等面向对象的编程语言中，异常本身就是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java 处理异常的方式是中断处理。异常指的并不是语法错误，语法错误，编译不通过，不会产生字...
Java的异常处理语法
最新发布
hdxx2022的博客
01-11 1061
catch的类型是Java语言中定义的或者程序员自己定义的，表示代码抛出异常的类型，异常的变量名表示抛出异常的对象的引用，如果catch捕获并匹配上了该异常，那么就可以直接用这个异常变量名，此时该异常变量名指向所匹配的异常，并且在catch代码块中可以直接引用。对于运行时异常，我们不要用try...catch来捕获处理，而是在程序开发调试阶段，尽量去避免这种异常，一旦发现该异常，正确的做法就会改进程序设计的代码和实现方式，修改程序中的错误，从而避免这种异常。异常的对象从哪里来呢？比如除数为0的异常。
C++中异常处理与if判断的问题
tinyway的专栏
01-09 1659
异常情况也就是对情况是否异常做出的判断，那么异常处理和if判断语句有什么区别呢？各有什么好处？ if-else 方式的好处在于更贴近与逻辑思维，性能优于Exception。相对于Exception，其缺点是，不适合OOP，语义不明显，不易于错误错误跟踪或错误提示较少，并且类型比较单一。exception方法的好处在于是业务逻辑和异常处理分离（代码相对清晰），try中处理业务，catch中
Java自定义全局异常类及原理
无
04-28 1963
Java异常类 1.自定义异常 public class BusinessException extends RuntimeException { private int code; private String message; public BusinessException(int code) { super(); this.code = code; } public BusinessException(int code,
Java异常处理机制
weixin_30955617的博客
08-04 223
Java中的异常（Exception）又称为例外，是一个在程序执行期间发生的事件，它中断正在执行的程序的正常指令流。为了能够及时有效地处理程序中的运行错误，必须使用异常类。 一、异常简介 在程序中，错误可能产生于程序员没有预料到的各种情况，或者超出程序员可控范围的环境，例如用户的坏数据、试图打开一个不存在的文件等。为了能够及时有效地处理程序中的运行错误，Java 专门引入了异常类。...
异常处理和IF else语句判断的区别？
zhaoyashan的专栏
12-28 3719
<br />在这我就写一点自己的小看法吧。<br />      异常处理应该可以说成是那个编程高手为我们会出现的问题做出来的错误情况的打包，想的错误情况也比我们本身要知道的要多，<br />如果单用if else语句来判断的话，我们不可能对所有情况进行判断，就算能判断也要花费好多精力，如果不小心少写了一个错误判断，被其他人找到了对我们也不是一个好事。<br />      我个人认为如果是自己使用的软件，可以不用异常处理，不过给别人使用的软件我还是建议大家用异常处理。
Java异常类型
qq_37723158的博客
01-29 275
所有异常类型都是内置类Throwable的子类。因此，Throwable在异常类层次结构的顶层。紧接着Throwable下面的是两个把异常分成两个不同分支的子类。一个分支是Exception。 该类用于用户程序可能捕捉的异常情况。它也是你可以用来创建你自己用户异常类型子类的类。在Exception分支中有一个重要子类RuntimeException。该类型的异常自动为你所编写的程序定义并且包
Java异常处理机制详解
"Java异常处理是Java编程中不可或缺的一部分，旨在确保程序在遇到错误或意外情况时仍能优雅地运行。异常是程序执行期间可能出现的任何中断正常流程的事件，如除以零、数组越界或文件未找到等。异常分为编译时异常和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值