Java SE -- 异常

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

异常框架

概述

当程序出现问题时，将错误交给虚拟机进而停止程序执行的情况，我们称为异常。

Exception和Error的区别

Exception

这种错误类型程序是可以处理的，Exception包含受检异常和非受检异常，这一点我们后文会展开详细介绍。

Error

这种错误一般都是OOM，Java虚拟机运行错误(Virtual MachineError)，或者类定义错误(NoClassDefFoundError)。我们不建议通过catch进行捕获。而是让虚拟机进行线程终止。

受检异常和非受检异常

受检异常

受检异常一般在调用时，用户就需要对其进行处理，如果不处理则不会通过编译。

例如FileInputStream，如果我们没有对其构造方法抛出的错误(即受检异常)进行处理，我们是无法通过编译的。

img

非受检异常

非受检异常一般是运行时异常，常见的有空指针异常、非法参数异常、算数异常、数组越界等。

Throwable常用的方法有哪些

  1. String getMessage():返回异常的错误的简要信息。
  2. String toString():返回异常发生时的详细信息。
  3. String getLocalizedMessage():返回异常本地化信息。
  4. void printStackTrace():在控制台上打印堆栈追踪信息。

异常抛出示例

我们自定义一个受检异常

public class ArithmeticException extends Exception {
    @Override
    public String getMessage() {
        return "自定义算术异常";
    }
}

编写一个除法的函数

private int calculate(int  number,int divNum) throws ArithmeticException {
        if (divNum==0){
            throw new ArithmeticException();
        }
        return number / divNum;
    }

测试代码

@Test
    public void calculateTest(){
        int number=20;
        try {
            int result = calculate(number,0);
            System.out.println(result);
        } catch (ArithmeticException e) {
            logger.error("calculateTest计算失败，请求参数:[{}],错误原因[{}]",number,e.getMessage(),e);
            /**
             * 输出
             * [main] ERROR com.guide.exception.ExceptionTest - calculateTest计算失败，请求参数:[20],错误原因[自定义算术异常]
             */
        }
    }

try-catch运行原理

try块代码执行报错 若有catch模块catch则会对其进行捕获处理，例如我们上文捕获了ArithmeticException ，那么catch (ArithmeticException e) 实质上会做一个Exception e = new ArithmeticException()的动作，进而按照用户的想法进行错误捕获逻辑处理。

多异常捕获处理技巧

原则

  1. 有几个异常就处理几个异常，如果无法处理就抛出
  2. 父类exception放在最下方
  3. 多异常建议使用|进行归类整理

代码示例

如下所示，我们自定义一个自定义错误函数

private int calculate(int  number,int divNum) throws ArithmeticException,FileNotFoundException, UnknownHostException, IOException {
        if (divNum==0){
            throw new ArithmeticException();
        }
        return number / divNum;
    }

假定UnknownHostException 是用户配置问题，我们无法处理，那么就抛出，其他错误一一捕获，所以我们的代码可能是这样

@Test
    public void calculateTest(){
        int number=20;

        int result = 0;
        try {
            result = calculate(number,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e){

        }catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(result);

    }

实际在为了让代码更加整洁高效。生成的catch块也只是一个公共的代码块，所以我们最终的代码应该是下面这个样子

@Test
    public void calculateTest()throws UnknownHostException{
        int number=20;

        int result = 0;
        try {
            result = calculate(number,0);
        } catch (ArithmeticException|FileNotFoundException e) {
            logger.error("calculateTest执行报错，用户执行出错或者文件数据获取失败，请求参数[{}],错误信息[{}]",number,e.getMessage(),e);
        } catch (IOException e) {
            logger.error("calculateTest执行报错，文件操作异常，请求参数[{}],错误信息[{}]",number,e.getMessage(),e);
        }catch (Exception e){
            logger.error("calculateTest执行报错，请求参数[{}],错误信息[{}]",number,e.getMessage(),e);

        }
        System.out.println(result);

    }

注意事项

使用|运算符之后e会变为final变量，用户无法改变引用的指向

img

throw于throws的区别

  1. throws放在函数上，throw放在函数内
  2. throws可以跟多个错误类，throw只能跟单个异常对象

特殊的异常对象 RuntimeException

概述

使用runtime异常类时，在函数内throw则函数上不用throws，编译可以正常通过

代码范例

如下代码，即使没有throws ArithmeticException(ArithmeticException为runtime的子类)，编译照样通过

class Demo
{
    int div(int a,int b)throws Exception//throws ArithmeticException
    {

        if(b<0)
            throw new Exception("出现了除数为负数了");
        if(b==0)
            throw new ArithmeticException("被零除啦");
        return a/b;
    }
}

原因

在程序运行时，正常的exception必须在函数上throws 错误，让开发人员进行异常修复，但是runtime异常比较特殊，他编译时不检测函数是否又throws，这样做的目的就是有意让开发者不知道这一错误，让错误在运行时暴露，由开发人员修正代码来规范程序。

java异常层次结构

java异常层次结构如下图所示

img

finally关键字

finally无论异常是否执行，在try块结束后必定会运行的，需要注意的是如果程序出现异常，finally中有return语句的话，catch块的return将没有任何作用，代码如下所示

public static int func() {
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            return 2;
        } finally {
            return 1;
        }
    }

finally常规用法(资源释放)

//读取文本文件的内容
        Scanner scanner = null;
        try {
            scanner = new Scanner(new File("D://read.txt"));
            while (scanner.hasNext()) {
                System.out.println(scanner.nextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }

try-with-resources——优雅解决方案

可以看到上述代码十分冗长，可读性十分差劲，于是java对这种做法做了相应改进，如下所示，对于继承Closeable、AutoCloseable的类都可以使用以下语法完成资源加载和释放

 try (Scanner scanner = new Scanner(new File("D://read.txt"))) {
            while (scanner.hasNext()) {
                System.out.println(scanner.nextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

finally 中的代码一定会执行吗

不一定，如下代码所示，当虚拟机执行退出的话，finally是不会被执行的

@Test
    public void finallyNoRun() {
        try {
            System.out.println("try code run.....");
            System.exit(0);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("finally run...");
        }

        /**
         * 输出结果
         * try code run.....
         */
    }

异常使用注意事项

不要在finnally中使用return

函数执行的try块返回值会被缓存的本地变量中，当finally进行return操作就会覆盖这个本地变量

@Test
    public void finallyReturnTest() {
        System.out.println(finallyReturnFun());
        /**
         * 输出结果
         * finallyReturnVal
         * 原因:try块的return会被缓存在本地变量中，
         * 当finally有return时，会覆盖这个结果
         */
    }

    private String finallyReturnFun() {
        try {
            int ten = 10;
            return "tryRetunVal";
        } catch (Exception e) {
            System.out.println("报错了。。。。");
        } finally {
            return "finallyReturnVal";
        }

    }

异常不处理就抛出

捕获异常是为了处理它，不要捕获了却什么都不处理而抛弃之，如果不想处理它，请 将该异常抛给它的调用者。最外层的业务使用者，必须处理异常，将其转化为用户可以理解的内容。

代码示例

自定义一个异常

public class MyIllegalArgumentException extends Exception {

    public MyIllegalArgumentException(String msg) {
        super(msg);
    }

    @Override
    public String getMessage() {
        return super.getMessage();
    }
}

测试代码

 @Test
    public void checkTest() {
        String param = null;
        try {
            check(null);
        } catch (MyIllegalArgumentException e) {

            logger.info("参数校验异常，请求参数[{}],错误信息[{}]", param, e.getMessage(), e);
            /**
             * [main] INFO com.guide.exception.ExceptionTest - 参数校验异常，请求参数[null],错误信息[字符串不可为空]
             */
        }
    }


    private void check(String str) throws MyIllegalArgumentException {
        if (str == null || str.length() <= 0) {
            throw new MyIllegalArgumentException("字符串不可为空");
        }
    }

try块代码使用粒度和性能探讨

  1. try-catch阻止jvm试图进行的优化，所以当我们要使用try块时，使用的粒度尽可能要小一些。
  2. 现代标准遍历模式并不会导致冗余检查，所以我们无需为了避免越界检查而使用try块解决问题
/**
     * 异常捕获后不要用来做流程控制，条件控制。
     * try catch 阻止了jvm原本会对其做的优化工作
     */
    @Test
    public void stackPopByCatch() {
        long start = System.currentTimeMillis();
        try {
            Stack stack = new Stack();
            for (int i = 0; i < 100_0000; i++) {
                stack.push(i);
            }
            while (true) {
                try {
                    stack.pop();
                } catch (Exception e) {
                    System.out.println("出栈结束");
                    break;
                }
            }
        } catch (Exception e) {

        }


        long end = System.currentTimeMillis();
        System.out.println("使用try进行异常捕获，执行时间:" + (end - start));


        start = System.currentTimeMillis();
        Stack stack2 = new Stack();
        for (int i = 0; i < 100_0000; i++) {
            stack2.push(i);

        }
        for (int i = 0; i < stack2.size(); i++) {
            stack2.pop();
        }
        end = System.currentTimeMillis();
        System.out.println("使用逻辑进行出栈操作，执行时间:" + (end - start));

        /**
         * 输出结果
         * 出栈结束
         * 使用try进行异常捕获，执行时间:94
         * 使用逻辑进行出栈操作，执行时间:52
         */
    }

日志打印规范

  1. 不要使用JSON工具，因为某些get方法可能会抛出异常
  2. 记录参数，错误信息，堆栈信息
/**
     * 打印日志格式规范
     */
    @Test
    public void logShowTest() {
        Map inputParam = new JSONObject().fluentPut("key", "value");
        try {
            logShow(inputParam);
        } catch (ArithmeticException e) {
            logger.error("inputParam:{} ,errorMessage:{}", inputParam.toString(), e.getMessage(), e);
            /**
             * [main] ERROR com.guide.exception.ExceptionTest - inputParam:{"key":"value"} ,errorMessage:自定义算术异常
             * com.guide.exception.ArithmeticException: 自定义算术异常
             *     at com.guide.exception.ExceptionTest.logShow(ExceptionTest.java:166)
             */
        }
    }


    private int logShow(Map inputParam) throws ArithmeticException {
        int zero = 0;
        if (zero==0){
           throw new ArithmeticException();
        }
        return 19 / zero;
    }

异常是否耗时？为什么会耗时？

如下代码所示，可以看到频繁抛出和捕获对象是非常耗时的，所以我们不建议使用异常来作为处理逻辑，我们完全可以和前端协商好错误码从而避免没必要的性能开销

private int testTimes;

    public ExceptionTest(int testTimes) {
        this.testTimes = testTimes;
    }

    public void newObject() {
        long l = System.currentTimeMillis();
        for (int i = 0; i < testTimes; i++) {
            new Object();
        }
        System.out.println("建立对象：" + (System.currentTimeMillis() - l));
    }

    public void newException() {
        long l = System.currentTimeMillis();
        for (int i = 0; i < testTimes; i++) {
            new Exception();
        }
        System.out.println("建立异常对象：" + (System.currentTimeMillis() - l));
    }

    public void catchException() {
        long l = System.currentTimeMillis();
        for (int i = 0; i < testTimes; i++) {
            try {
                throw new Exception();
            } catch (Exception e) {
            }
        }
        System.out.println("建立、抛出并接住异常对象：" + (System.currentTimeMillis() - l));
    }

    public void catchObj() {
        long l = System.currentTimeMillis();
        for (int i = 0; i < testTimes; i++) {
            try {
                new Object();
            } catch (Exception e) {
            }
        }
        System.out.println("建立,普通对象并catch：" + (System.currentTimeMillis() - l));
    }

    public static void main(String[] args) {
        ExceptionTest test = new ExceptionTest(100_0000);
        test.newObject();
        test.newException();
        test.catchException();
        test.catchObj();
        /**
         * 输出结果
         * 建立对象：3
         * 建立异常对象：484
         * 建立、抛出并接住异常对象：539
         * 建立,普通对象并catch：3
         */
    }
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】try 语句块和异常处理
Nebula的博客
07-14 4658
C++ try 语句块和异常处理相关知识点总结
try标准代码块
leechard的专栏
05-31 234
#import <Foundation/Foundation.h> #import "Fraction.h" int main(int argc, const char * argv[]) { @autoreleasepool { // insert code here... Fraction *f = [[Fraction alloc] init]; @try { [f print]; ...
C++之 try语句块和异常处理
m0_53853047的博客
10-27 5967
C++之 try语句块和异常处理
Java培训：面向对象try的用法
zy1992As的博客
10-24 565
在try代码块中发生除0异常外，程序会通过catch语句捕获异常，第8行代码在catch语句中通过调用Exception对象的getMessage()方法，返回异常信息“/by zero”。上述语法格式中，在try代码块中编写可能发生异常的Java语句，在catch代码块中编写针对异常进行处理的代码。需要注意的是，在try代码块中，发生异常语句后面的代码是不会被执行的，如文件4-25中第6行代码的打印语句就没有执行。下面使用try...catch语句对文件4-24中出现的异常进行捕获，如文件4-25所示。
深入学习try-catch-finally以及各个代码块有无返回值的区别
Promise_J_Z
11-29 509
一、try-catch 说明：在出现try-catch代码块的情况，会先进入try代码块，然后监控整个try中的代码，如果出现异常就会catch代码块中。 实例代码： int i = 0; try { i = 10; } catch (Exception e) { i = 20; } 对应字节码： 首先是第0-1行，对应的就是int i= 0 ，将0存入本地变量1号槽位 2-..
try语句块和异常处理
xiaoyuxianshenging的博客
02-13 1391
一般当程序的某部分检测到异常即（异常检测），出现错误无法继续执行，则会抛出异常信息，通常被专门代码来处理即（异常处理）。我们用throw表达式获取异常信息，用try语句块内含多个catch子句来处理异常代码。 throw 表达式 程序的异常检测部分使用throw表达式来获得异常，其中表达式的类型就是抛出的异常类型，在stdexcept头文件中定义了几个常见的异常类型，如： runtime_e
try块的使用
路人甲的路人乙的专栏
03-09 1017
java程序中try应该怎么使用呢？ 在睿智的时候，架构师（中兴）萧哥告诉我不要动不动就把业务上的错误包装成异常抛出，再捕获处理，因为抛出异常再try捕获处理消耗的性能是巨大的。要把业务上的错误在写程序时要考虑到，然后手工处理。在来这家公司之前，我一直都是这么做的，但是现在看到公司的程序不管是业务上还是程序上的异常全部是抛出异常，try捕获处理的。这然我很疑问，这两种方法到底如恶化选择呢？ 先...
（30）try语句块和异常处理
革命队伍的螺丝钉
11-13 3418
异常是指存在于运行时的反常行为，这些行为超出了函数正常功能的范围。 当程序的某部分检测到一个它无法处理的问题时，需要用到异常处理。异常处理机制为程序中异常检测和异常处理这两部分的协作提供支持。在C++语言中，异常处理包括： 一.throw表达式，异常检测部分使用throw表达式来表示它遇到了无法处理的问题。我们说throw引发了异常。 二.try语句块，异常处理部分使用try语句处理异常。t
idea自动生成try/catch代码块的快捷键
热门推荐
EastChilde的博客
02-18 1万+
选定代码块，快捷键：Ctrl+Alt+T
Java学习笔记 深入理解try，catch，finally代码块
LangWeiXian_的博客
03-31 207
1，先看一段代码 package day08.blogTryCatch; public class Demo1 { public static void main(String[] args) { Person p = heihei(); System.out.println(p.age); } public static Person heihei(){ Person p = new Person(); try{.
try代码块与日志
xiangwang2016的博客
12-26 1173
异常分类 ​​ try 代码块 try-catch-finally 是处理程序异常的三部曲。当存在 try 时，可以只有 catch 代码块，也可以只有 finally 代码块，就是不能单独只有 try 这个光杆司令。 finally 是在 return 表达式运行后执行的。此时return 的结果已经被暂存起来 。finally 代码块执行结束后再...
JS中try-catch代码块的应用场景
高先生的猫
06-17 1038
try-catch属于同步代码块，因此无法捕获异步（重新开辟的线程，例如定时器，异步请求）代码中的异常，即能被try-catch捕获的异常，必须是在报错时候，线程的执行进入了try-catch代码块时，才能被捕获异常。 代码 try{ setTimeout(()=>{//宏任务 a.b//无法捕获 },10) new Promise((resolve,reject)=>{//微任务 a.b//无法捕获 //通常.
python中try语句_【转】python try语句相关(try/except/else/finally)
weixin_39713219的博客
11-26 544
1、try - except作用： 捕获程序在执行时遇到的异常情况，即一些报错。什么啥玩意儿没定义啊，符号又错了啊之类的你懂得。意义： 因为程序在发现某个错误时，往往会中断不再向下执行，如下例子说明问题：很明显，我们并没有定义b, 就将它赋值给a, 现在我们运行如下：不出所料提示NameError, 发现错误就报错，不再执行下面的程序。现在我们用try/except写一下：打印：我们从这个例子可...
Try-Catch-Finally代码块区别
qq_26552373的博客
04-14 670
try块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。 catch块：用于处理try捕获到的异常。 finally块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return 语句时，finally 语句块将在方法返回之前被执行。 但是在以下4种特殊情况下，finally块不会被执行： 在finally 语句块第一行发生了异常。因为在其他行，finally块还是会得到执行 在前面的代码中用了
Java try catch语句块中try（）的括号中代码作用
有灯就可以编程的博客
06-19 1万+
应用场景：当我们使用带资源的try语句时，使用finally也许会造成一个异常被覆盖的问题，即try语句块中会抛出某个异常，执行finally语句块中跑出了同样的异常，这样的话就会导致原有的异常会丢失，转而抛出的finally语句中的异常。这时我们可以使用带资源的try语句来处理（前提是这个资源实现了AutoCloseable接口的类） 格式如下：括号中可以写多行语句，会自动关闭括号中的资...
枚举工具类
最新发布
qq_43049583的博客
08-04 269
java枚举工具类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值