究极异常处理逻辑——多层次异常的处理顺序

已于 2022-08-01 11:25:41 修改
阅读量768 收藏
点赞数
分类专栏： Java开发中出现的异常 实习经历
于 2022-08-01 11:22:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_Love_U/article/details/126097343
版权

java 异常处理

目录

多层次异常的处理顺序

之前在牛客做笔试题的时候，由于遇到了一道多层次异常相关的题，所以对多层次异常的处理顺序格外留心，在上周工作增加并发锁的时候，由于是锁的嵌套，也就是 异常处理 嵌套 异常处理。于是决定深究一下多层次异常处理的优先级。

零、代码执行环境

IDEA版本：2022.1.3

JDK版本：jdk1.8.0_181

一、try、catch 和 finally 中 return 的优先级问题

首先，我们先来探究产生是否产出异常对 try、catch 和 finally 中 return 的优先级 的影响

测试代码：


public class Test {  
  
    public static void main(String[] args) {  
        System.out.println("产生异常时：a = " + test1());
        System.out.println("未产生异常时：a = " + test2());
    
  
    public static String test1() {  
        String res = "初始内容 ";  
        try {  
            int a = 1 / 0;  
            return res + " + try 返回了";  
        } catch (Exception e) {  
            res += " + catch 执行了";  
            return res + " + catch 返回了";  
        } finally {  
            res += " + finally 执行了";  
            return res + " + finally 返回了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }  
  
    public static String test2() {  
        String res = "初始内容 ";  
        try {  
//            int a = 1 / 0;  
            return res + " + try 返回了";  
        } catch (Exception e) {  
            res += " + catch 执行了";  
            return res + " + catch 返回了";  
        } finally {  
            res += " + finally 执行了";  
            return res + " + finally 返回了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }
}

运行结果：

产生异常时：初始内容  + catch 执行了 + finally 执行了 + finally 返回了
不产生异常时：初始内容  + finally 执行了 + finally 返回了

结果分析：

通过结果可以看出，无论是否产生异常，一旦 finally {} 语句块中含有 retuan 那么都会执行 finally {} 语句中的 retuan 语句。

二、try 和 catch 中 return 的优先级问题

测试代码：

  
  
    public static void main(String[] args) {  
        System.out.println("产生异常时：" + test1());  
        System.out.println("不产生异常时：" + test2());  
    }  
  
    public static String test1() {  
        String res = "初始内容 ";  
        try {  
//            int a = 1 / 0;  
            return res + " + try 返回了";  
        } catch (Exception e) {  
            res += " + catch 执行了";  
            return res + " + catch 返回了";  
        } finally {  
            System.out.println("finally 执行了");  
            res += " + finally 执行了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }
      
    public static String test2() {  
        String res = "初始内容 ";  
        try {  
            int a = 1 / 0;  
            return res + " + try 返回了";  
        } catch (Exception e) {  
            res += " + catch 执行了";  
            return res + " + catch 返回了";  
        } finally {  
            System.out.println("finally 执行了");  
            res += " + finally 执行了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }  
}

运行结果：

finally 执行了
不产生异常时：初始内容  + try 返回了
finally 执行了
产生异常时：初始内容  + catch 执行了 + catch 返回了

结果分析：

不产生异常时：执行 try {} 语句中的 retuan 语句。
产生异常时：执行 catch {} 语句中的 retuan 语句

值得注意的是： finally {} 语句中的语句也执行了，但是对于字符串 res 的操作没有生效。

如果是返回基本类型的值，那么在缓存时也是缓存值本身，所以后面在finally块中重新赋值时，方法返回的值不会受finally块中重新赋值的影响；

如果返回的是引用类型的值，那么在缓存时，缓存的是引用类型对象的引用，所以虽然后面在finally块中重新赋值时（重新指向另一个对象），方法返回的值不会受到影响，但是如果是修改对象的属性，那么会影响到返回的值。

参考链接：finally语句中对变量进行赋值的问题

三、finally 中 return 对 catch 中异常的影响


public class Test {  
  

    public static void main(String[] args) {  
        System.out.println("finally 有 return 时：" + test1());  
        System.out.println("finally 无 return 时：" + test2());  
    }  
    
	public static String test1() {  
	    String res = "初始内容 ";  
	    try {  
	        int a = 1 / 0;  
	        return res;  
	    } catch (Exception e) {  
	        int a = 1 / 0;  
	        res += " + catch 执行了";  
	        return res;  
	    } finally {  
	        res += " + finally 执行了";  
	        return res ;  
	    }  
	    // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
	}  
	  
	public static String test2() {  
	    String res = "初始内容 ";  
	    try {  
	        int a = 1 / 0;  
	        return res;  
	    } catch (Exception e) {  
	        int a = 1 / 0;  
	        res += " + catch 执行了";  
	        return res;  
	    } finally {  
	        res += " + finally 执行了";  
	    }  
	    // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
	}
  
}

运行结果：

finally 有 return 时：初始内容  + finally 执行了
Exception in thread "main" java.lang.ArithmeticException: / by zero

结果分析：

根据结果可以看出，如果 finally {} 代码块中有 retuan 时， catch {} 中的异常不会被处理。

四、多层次 try 、 catch 和 finally 中 return 的优先级问题


public class Test {  
  
  
    public static void main(String[] args) {  
        System.out.println("不产生异常时：" + test1());  
        System.out.println("内部 try 产生异常时：" + test2());  
        System.out.println("内部 catch 也产生异常时：" + test3());  
    }  
  
    public static String test1() {  
        String res = "初始内容";  
        try {  
            try {  
//                int a = 1 / 0;  
                return res;  
            } catch (Exception e) {  
                res += " + 内部代码块的 catch 执行了";  
                return res;  
            } finally {  
                res += " + 内部代码块的 finally 执行了";  
                return res + " + 内部 finally 返回了";  
            }  
            // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
        } catch (Exception e) {  
            res += " + 外部代码块的 catch 执行了";  
            return res;  
        } finally {  
            res += " + 外部代码块的 finally 执行了";  
            return res + " + 外部 finally 返回了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }  
  
    public static String test2() {  
        String res = "初始内容";  
        try {  
            try {  
                int a = 1 / 0;  
                return res;  
            } catch (Exception e) {  
                res += " + 内部代码块的 catch 执行了";  
                return res;  
            } finally {  
                res += " + 内部代码块的 finally 执行了";  
                return res + " + 内部 finally 返回了";  
            }  
            // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
        } catch (Exception e) {  
            res += " + 外部代码块的 catch 执行了";  
            return res;  
        } finally {  
            res += " + 外部代码块的 finally 执行了";  
            return res + " + 外部 finally 返回了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }  
  
    public static String test3() {  
        String res = "初始内容";  
        try {  
            try {  
                int a = 1 / 0;  
                return res;  
            } catch (Exception e) {  
                int a = 1 / 0;  
                res += " + 内部代码块的 catch 执行了";  
                return res;  
            } finally {  
                res += " + 内部代码块的 finally 执行了";  
                return res + " + 内部 finally 返回了";  
            }  
            // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
        } catch (Exception e) {  
            res += " + 外部代码块的 catch 执行了";  
            return res;  
        } finally {  
            res += " + 外部代码块的 finally 执行了";  
            return res + " + 外部 finally 返回了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }
  
}

运行结果：

不产生异常时：初始内容 + 内部代码块的 finally 执行了 + 外部代码块的 finally 执行了 + 外部 finally 返回了
内部 try 产生异常时：初始内容 + 内部代码块的 catch 执行了 + 内部代码块的 finally 执行了 + 外部代码块的 finally 执行了 + 外部 finally 返回了
内部 catch 也产生异常时：初始内容 + 内部代码块的 finally 执行了 + 外部代码块的 finally 执行了 + 外部 finally 返回了

结果分析：

不产生异常时：正常执行 try {} 中语句，由于外部代码块 finally {} 中有 return 语句，所以只执行外部 finally {} 中的 return 语句。符合我们在 一、try 和 finally 中 return 的优先级问题 中的结论。

try 产生异常时：代码执行 catch {} 部分，由于外部代码块 finally {} 中有 return 语句，所以只执行外部 finally {} 中的 return 语句。符合我们在 一、try 和 finally 中 return 的优先级问题 中的结论。

try 和 catch 同时产生异常时：由于外部代码块 finally {} 中有 return 语句，所以程序不会处理 catch {} 中的异常，故结果和不产生异常时相同。符合我们在 三、finally 中 return 对 catch 中异常的影响 中的结论。

五、多层次 try 和 catch 中 return 的优先级问题

为了验证最后一个结论，我们在 finally {} 中去掉 return 语句，再次执行。

测试代码：


public class Test {  
  
  
    public static void main(String[] args) {  
        System.out.println("不产生异常时：" + test1());  
        System.out.println("内部 try 产生异常时：" + test2());  
        System.out.println("内部 catch 也产生异常时：" + test3());  
    }  
  
    public static String test1() {  
        String res = "初始内容";  
        try {  
            try {  
//                int a = 1 / 0;  
                return res + " + 内部代码块的 try 返回";  
            } catch (Exception e) {  
                res += " + 内部代码块的 catch 执行了";  
                return res + " + 内部代码块的 catch 返回";  
            } finally {  
                res += " + 内部代码块的 finally 执行了";  
            }  
            // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
        } catch (Exception e) {  
            res += " + 外部代码块的 catch 执行了";  
            return res + " + 外部代码块的 catch 返回";  
        } finally {  
            res += " + 外部代码块的 finally 执行了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }  
  
    public static String test2() {  
        String res = "初始内容";  
        try {  
            try {  
                int a = 1 / 0;  
                return res + " + 内部代码块的 try 返回";  
            } catch (Exception e) {  
                res += " + 内部代码块的 catch 执行了";  
                return res + " + 内部代码块的 catch 返回";  
            } finally {  
                res += " + 内部代码块的 finally 执行了";  
            }  
            // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
        } catch (Exception e) {  
            res += " + 外部代码块的 catch 执行了";  
            return res + " + 外部代码块的 catch 返回";  
        } finally {  
            res += " + 外部代码块的 finally 执行了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }  
  
    public static String test3() {  
        String res = "初始内容";  
        try {  
            try {  
                int a = 1 / 0;  
                return res + " + 内部代码块的 try 返回";  
            } catch (Exception e) {  
                int a = 1 / 0;  
                res += " + 内部代码块的 catch 执行了";  
                return res + " + 内部代码块的 catch 返回";  
            } finally {  
                res += " + 内部代码块的 finally 执行了";  
            }  
            // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
        } catch (Exception e) {  
            res += " + 外部代码块的 catch 执行了";  
            return res + " + 外部代码块的 catch 返回";  
        } finally {  
            res += " + 外部代码块的 finally 执行了";  
        }  
        // finally 中有 return 的话，这之后的代码由于不会被执行，而产生会编译错误  
    }
}

运行结果：

不产生异常时：初始内容 + 内部代码块的 try 返回
内部 try 产生异常时：初始内容 + 内部代码块的 catch 执行了 + 内部代码块的 catch 返回
内部 catch 也产生异常时：初始内容 + 内部代码块的 finally 执行了 + 外部代码块的 catch 执行了 + 外部代码块的 catch 返回

结果分析：

不产生异常时：正常执行 try {} 中的 return 。

try 产生异常时：由于 finally {} 中没有 return 语句，所以执行 catch {} 中有 return 语句，但是 finally {} 中的逻辑会执行。

catch 也产生异常时：由于内部 finally {} 中没有 return 语句，所以异常会向外抛出，被外部 catch {} 捕捉到，执行外部 catch {} 中有 return 语句。其中外部 finally {} 中的逻辑均会执行。

六、写在后面

欢迎关注，会经常记录一些学习思考笔记。如有错误与补充，感谢您的指出。

欢迎随时留言讨论，与君共勉，知无不答！

Java咩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之异常
weixin_55787308的博客
08-03 726
当JDK 中的异常类型不能满足程序的需要时，可以自定义异常类。使用自定义异常的步骤。
java 多个try_Java中多个异常的捕获顺序(多个catch)
weixin_36039452的博客
02-12 4183
Java代码importjava.io.IOException;publicclassExceptionTryCatchTest{publicvoiddoSomething()throwsIOException{System.out.println("dosomthing");}publicstaticvoidmain(String[]args){ExceptionTry...
(十一)：Java中异常的捕获顺序(多个catch)
lukuijun1981的专栏
02-28 1958
[code="java"]import java.io.IOException; public class ExceptionTryCatchTest { public void doSomething() throws IOException{ System.out.println("do somthing"); } public static void main(Strin...
java中异常 try，catch,finally在不同情况下的执行顺序
happyAliceYu的博客
09-10 1139
首先明确：finally语句在try或catch中的return语句执行之后返回之前执行finally中的语句，但是finally中的修改语句不会影响try或catch中 return已经确定的返回值，若finally里也有return语句则覆盖try或catch中的return语句直接返回 1、异常处理过程 把会出现异常的程序段放在try中，当抛出异常的时候就会在系统中
Java中有多个异常, 如何确定捕获顺序(多个catch),先从上到下执行,判断异常的大小,如果包含捕到异常,就进入这个catch,后面的就不再执行
mhx123456789的博客
07-24 654
Java中有多个异常, 如何确定捕获顺序(多个catch),先从上到下执行,判断异常的大小,如果包含捕到异常,就进入这个catch,后面的就不再执行
数据结构顺序表究极版本|发布版—顺序表.cpp
10-21
博主第一次发布的小程序，是数据结构实验课的第一次实验顺序表的创建及其应用。其中包含创建顺序表，输出顺序表，在顺序表中插入元素，在顺序表中删除元素，合并两个顺序表，反转顺序表这几个具体的方法。
美团面试官：SpringBoot统一接口返回和全局异常处理怎么做？
wdj_yyds的博客
05-16 418
现在大多数公司项目框架，基本都是属于前后端分离模式，这种模式会涉及到一个前后端对接问题，无论是对前端或者是后台服务，维护一套完善且规范的接口是非常有必要的，这样不仅能够提高对接效率，也可以让我的代码看起来更加简洁优雅。 修改前后最大的区别是我们不用在每个接口单独捕获异常，也不用在每个接口都要组装一遍返回参数，可以参考下面这张对比图： 一、SpringBoot不使用统一返回格式 默认情况下，SpringBoot会有如下三种返回情况。 1.1 字符串 @GetMapping("/getUse
SQL Server使用游标处理Tempdb究极竞争-DBA问题-程序员必知
12-15
DBAs和程序员应该密切关注tempdb的使用情况，采取适当的优化策略，如合理分配tempdb资源，减少不必要的临时对象创建，以及在某些情况下考虑使用游标来替代传统的方法，以解决深层次的tempdb竞争问题。记住，每个系统...
字节跳动面试官：SpringBoot统一接口返回和全局异常处理怎么玩？(1)
最新发布
2401_84436034的博客
04-19 610
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
java抛出异常顺序_Java-再来学习下异常处理
weixin_39554775的博客
02-25 641
一、前言只要写过Java代码，基本上都会遇到异常，由于以前学习的不够系统，所以趁现在有时间，再来重新回顾及梳理下Java的异常处理。二、异常处理1. 概念当一个用户在使用我们的程序期间，如果由于程序的错误或一些外部环境的影响造成用户数据的丢失，用户可能就不会再使用这个程序了，为了避免这种事情的发生，一般我们的程序应该能做到如下几点：向用户通报错误；保存所有的工作结果；允许用户以妥善的形式退出程序；...
异常的分级分类与处理策略
weixin_30851867的博客
03-07 509
异常的分级分类： .NET异常：.NET调用过程中产生的异常，对于终端用户来说这些异常不应该出现，应该在系统测试阶段就解决。 应用系统内部异常：是应用系统自己定义的异常，对于终端用户来说这些异常不应该出现，主要用来支持内部系统的决策，比如是否可恢复等，通常是将.NET异常转化而来。 应用系统业务逻辑异常：是应用系统自己定义，用来向终端用户...
Java中多个异常的捕获顺序(多个catch)
hijk7的博客
05-07 509
Java中多个异常的捕获顺序(多个catch)
Java中异常的捕获顺序(多个catch)
10年职场两茫茫，35岁凄凉奈若何
10-24 281
Java中异常的捕获顺序(多个catch)
多个全局异常处理类，怎么规定执行顺序
绅士jiejie的博客
07-02 1819
多个全局异常处理类，怎么规定执行顺序
java 捕获异常顺序_Java异常的捕获顺序（多个catch）
weixin_42721619的博客
02-13 740
importjava.io.IOException;public classExceptionTryCatchTest {public void doSomething() throwsIOException{System.out.println("do somthing");}public static voidmain(String[] args){ExceptionTryCatchTest ...
Java 异常处理、初始化块、final关键字、运算符优先级、循环语句
chy1984的博客
08-31 703
循环这种批量操作的场景，往往要尽量避免循环被异常终止，保证循环的继续执行，在循环体中可能发生异常的地方使用try…比如使用循环批量推送短信，某次循环时发生异常，没有在循环内处理异常，让异常抛到了循环外，则循环会被终止，循环中后续批次的消息都不会发送。形参属于局部变量，也可以用final修饰，调用方法传递实参时初始化该final变量，方法执行过程中，该final变量的值都不能被修改。在循环体中，慎用throw直接抛出异常，如果循环体中的异常直接抛到了循环体外，会导致循环终止，后续批次都不会执行。
全局异常捕捉处理
qq_18423811的博客
12-23 324
在项目中出现异常是在所难免的，但是出现异常后怎么处理？默认我们需要service层的异常需要抛出，而servcie层被Spring管理，默认Spring的事务回滚只对RunTimeException起作用，所以我们要把service层的编译器异常转换为运行时异常抛出。只有这种异常不需要影响业务，或者通过这种异常可以执行其他业务，我们才需要try。
多个catch()异常处理顺序验证
m0_49665279的博客
10-16 2457
try--catch理解： 当需要处理catch()处理异常时，没有继承关系的两个异常处理顺序随意，具有继承关系的两个异常先处理子异常，在处理父异常，任意一个catch()执行后，同级catch()均不在执行。 此时代码块 1 2可以互换，但代码块3必须在代码块2后面，此时路径有问题，报异常文件不存在； package com.ExceptionTest; import java.io.FileInputStream; import java.io.FileNotFoundException; i
java 多层异常_Java嵌套异常处理
weixin_29415667的博客
02-24 1290
我遇到了一个读取文本文件并对其进行分析的代码库。 我对使用异常的方式感到困惑。 单独的类AppFileReaderException已定义extends个异常，其中扩展类仅返回异常的错误消息。 此外，函数getSymbol()使用throws和try and catch block。 error()函数也有一个异常处理程序，可能导致嵌套异常！ 在基本的try和catch应该足够的情况下进行这种异常...
rcnn算法思想简单讲解概述————(究极简单的讲述和理解)_小馨馨的小翟的博客-cs
11-16
RCNN（Region-based Convolutional Neural Networks）算法是一种用于目标检测的深度学习算法。其思想是将输入图像分割成不同的区域，然后对每个区域进行卷积神经网络的特征提取，最后通过分类模块判断每个区域是否包含感兴趣的目标。 RCNN算法的主要步骤包括： 1. 输入图像经过Selective Search算法对图像进行区域提取，生成多个候选区域。 2. 将每个候选区域调整为同样的尺寸，以适应卷积神经网络的输入要求。 3. 使用预训练的卷积神经网络（如AlexNet或VGGNet）对每个候选区域进行前向计算，提取该区域的特征表示。 4. 将每个候选区域的特征表示输入到一个全连接层中进行分类，判断该区域是否包含目标物体，并输出预测结果。 5. 对于输出的预测结果，使用非极大值抑制（Non-Maximum Suppression，NMS）算法进行处理，去除重叠的检测结果。 RCNN算法的核心思想就是利用卷积神经网络来提取图像的特征表示，然后通过分类模块对每个候选区域进行分类预测。相比于传统的滑动窗口方法，RCNN算法只对候选区域进行处理，大大减少了计算量。 然而，RCNN算法存在的一个问题是速度较慢，因为需要对每个候选区域分别进行卷积神经网络的计算。为了提高速度，后续的改进算法如Fast R-CNN和Faster R-CNN应运而生。 总的来说，RCNN算法通过将图像分割为候选区域，并利用卷积神经网络提取区域特征，实现了目标检测的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值