try--catch--finally中return返回值执行的顺序（区别）

最新推荐文章于 2021-03-31 16:24:51 发布
最新推荐文章于 2021-03-31 16:24:51 发布
阅读量78 收藏
点赞数
原文链接：http://www.cnblogs.com/hoojjack/p/5873560.html
版权

1、try块中没有抛出异常，try、catch和finally块中都有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  static  int  NoException(){
          int  i= 10 ;
          try {
            System.out.println( "i in try block is：" +i);
            return  --i;
          }
          catch (Exception e){
            --i;
            System.out.println( "i in catch - form try block is：" +i);
            return  --i;
          }
          finally {     
            System.out.println( "i in finally - from try or catch block is：" +i);
            return  --i;
          }  
}

运行代码：

1
2
3
4
5
public  static  void  main( String [] args) {
         System.out.println( "=============NoException==================" );
         System.out.println(NoException());
         System.out.println( "===============================" );   
}

运行结果：

1
2
3
4
5
=============NoException==================
i  in  try  block  is ： 10
i  in  finally  - from  try  or  catch  block  is ： 9
8
===============================

 

执行顺序：

   执行try块，执行到return语句时，先执行return的语句，--i，但是不返回到main方法，执行finally块，遇到finally块中的return语句，执行--i,并将值返回到main方法，这里就不会再回去返回try块中计算得到的值。

结论：try-catch-finally都有return语句时，没有异常时，返回值是finally中的return返回的。从下面的字节码可以看出，try里的return将被忽略。

 

2.try块中没有抛出异常，仅try和catch中有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public  static  int  NoException1(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is：" +i);
                 return  --i;
             }
             catch (Exception e){
                 --i;
                 System.out.println( "i in catch - form try block is：" +i);
                 return  --i;
             }
             finally {           
                 System.out.println( "i in finally - from try or catch block is：" +i);
                 --i;
                 System.out.println( "i in finally block is：" +i);
                 //return --i;
             }
}

运行结果：

1
2
3
4
5
6
=============NoException1==================
i  in  try  block  is ： 10
i  in  finally  - from  try  or  catch  block  is ： 9
i  in  finally  block  is ： 8
9
===============================

执行顺序：

   try中执行完return的语句后，不返回，执行finally块，finally块执行结束后，返回到try块中，返回i在try块中最后的值。

结论：try-catch都有return语句时，没有异常时，返回值是try中的return返回的。

通过字节码，我们发现，在try语句的return块中，return 返回的引用变量（i 是引用类型）并不是try语句外定义的引用变量i，而是系统重新定义了一个局部引用i'（29行标红色框的，系统在这里面用第三个变量保存当前的值），这个引用指向了引用i对应的值，也就是try ，即使在finally语句中把引用i指向了值减1，因为return的返回引用已经不是i 而是临时的iload_3，所以引用i的对应的值和try语句中的返回值无关了。 

3.try块中抛出异常，try、catch和finally中都有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  static  int  WithException(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is：" +i);
                 i = i/ 0 ;
                 return  --i;
             }
             catch (Exception e){
                 System.out.println( "i in catch - form try block is：" +i);
                 --i;
                 System.out.println( "i in catch block is：" +i);
                 return  --i;
             }
             finally {           
                 System.out.println( "i in finally - from try or catch block is--" +i);
                 --i;
                 System.out.println( "i in finally block is--" +i);
                 return  --i;
             }
}

执行结果：

1
2
3
4
5
6
7
8
=============WithException==================
i  in  try  block  is ： 10
i  in  catch  - form  try  block  is ： 10
i  in  catch  block  is ： 9
i  in  finally  - from  try  or  catch  block  is -- 8
i  in  finally  block  is -- 7
6
===============================

执行顺序：

   抛出异常后，执行catch块，在catch块的return的--i执行完后，并不直接返回而是执行finally，因finally中有return语句，所以，执行，返回结果6。

结论：

   try块中抛出异常，try、catch和finally中都有return语句，返回值是finally中的return。

 

4.try块中抛出异常，try和catch中都有return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public  static  int  WithException1(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is：" +i);
                 i=i/ 0 ;
                 return  --i;
             } catch (Exception e){
                 System.out.println( "i in catch - form try block is：" +i);           
                 return  --i;
             } finally {
                                                                                                                                                                      
                 System.out.println( "i in finally - from try or catch block is：" +i);
                 --i;
                 System.out.println( "i in finally block is：" +i);
                 //return i;
             }
}

执行结果：

1
2
3
4
5
6
7
=============WithException1==================
i  in  try  block  is ： 10
i  in  catch  - form  try  block  is ： 10
i  in  finally  - from  try  or  catch  block  is ： 9
i  in  finally  block  is ： 8
9
===============================

执行顺序：

   抛出异常后，执行catch块，执行完finally语句后，依旧返回catch中的执行return语句后的值，而不是finally中修改的值。

结论：

   返回的catch中return值。

 

5.try、catch中都出现异常，在finally中有返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  static  int  WithException2(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is：" +i);
                 i=i/ 0 ;
                 return  --i;
             }
             catch (Exception e){
                 System.out.println( "i in catch - form try block is：" +i);
                 int  j = i/ 0 ;
                 return  --i;
             }
             finally {
                                                                                       
                 System.out.println( "i in finally - from try or catch block is：" +i);
                 --i;
                 --i;
                 System.out.println( "i in finally block is：" +i);
                 return  --i;
}

执行结果：

1
2
3
4
5
6
7
=============WithException2==================
i  in  try block  is ：10
i  in  catch - form try block  is ：10
i  in  finally -  from  try  or  catch block  is ：10
i  in  finally block  is ：8
7
===============================

执行顺序：   

   try块中出现异常到catch，catch中出现异常到finally，finally中执行到return语句返回，不检查异常。

结论：

   返回finally中return值。

6、只在函数最后出现return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public  static  int  WithException3(){
             int  i= 10 ;
             try {
                 System.out.println( "i in try block is：" +i);
                 i=i/ 0 ;
                 //return --i;
             }
             catch (Exception e){
                 System.out.println( "i in catch - form try block is：" +i);
                 //int j = i/0;
                 //return --i;
             }
             finally {
                                                                          
                 System.out.println( "i in finally - from try or catch block is：" +i);
                 --i;
                 --i;
                 System.out.println( "i in finally block is：" +i);
                 //return --i;
             }
             return  --i;
}

执行结果：

1
2
3
4
5
6
7
=============WithException3==================
i  in  try  block  is ： 10
i  in  catch  - form  try  block  is ： 10
i  in  finally  - from  try  or  catch  block  is ： 10
i  in  finally  block  is ： 8
7
===============================

 

总体结论：

结论一：

（1）return语句并不是函数的最终出口，如果有finally语句，这在return之后还会执行finally（return的值会暂存在栈里面，等待finally执行后再返回）

（2）try、catch、finally语句中，在如果try语句有return语句，则返回的之后当前try中变量此时对应的值，此后对变量做任何的修改，都不影响try中return的返回值

（3）如果finally块中有return 语句，则返回try或catch中的返回语句忽略。

（4）如果finally块中抛出异常，则整个try、catch、finally块中抛出异常


结论二：

   finally里面不建议放return语句，根据需要，return语句可以放在try和catch里面和函数的最后。可行的做法有四：
   （1）return语句只在函数最后出现一次。
   （2）return语句仅在try和catch里面都出现。
   （3）return语句仅在try和函数的最后都出现。
   （4）return语句仅在catch和函数的最后都出现。
   注意，除此之外的其他做法都是不可行的，编译器会报错。

注意：

（1）尽量在try或者catch中使用return语句。通过finally块中达到对try或者catch返回值修改是不可行的。

（2）finally块中避免使用return语句，因为finally块中如果使用return语句，会显示的消化掉try、catch块中的异常信息，屏蔽了错误的发生

（3）finally块中避免再次抛出异常，否则整个包含try语句块的方法回抛出异常，并且会消化掉try、catch块中的异常

 

Reference

[1] http://qing0991.blog.51cto.com/1640542/1387200

[2] https://mp.weixin.qq.com/s?__biz=MzIxNjA5MTM2MA==&mid=2652434506&idx=1&sn=f62a0cc1a18c628e1a52979921184af4&chksm=8c620fc5bb1586d3fe093e03749d9879dbbc4d540f3a68eb18b16d97d973a80a292ba6f7a0c3&mpshare=1&scene=23&srcid=0304GBqHaOULDvnnqLVyCoCk#rd

转载于:https://www.cnblogs.com/hoojjack/p/5873560.html

weixin_33828101
关注
谈谈Java中try-catch-finally中的return语句
09-02
2. 如果`finally`块有`return`语句，无论`try`块是否包含`return`，`finally`块的`return`语句都将决定最终的返回值，因为`finally`总是被执行。 理解这一点对于编写健壮、可靠的Java代码至关重要，特别是涉及资源...
面试题: try, catch, finally中都有return, 最后会返回谁的return?
十年
09-18 489
【代码】面试题: try, catch, finally中都有return, 最后会返回谁的return?
try catch finally 中包含return的四种情况，及返回结果
SUNxiaodui的博客
02-19 917
本文转载自：https://www.cnblogs.com/sunshineweb/p/7656463.html
try，catch，finally结构中return的返回值
chen404897439的博客
02-28 1113
实验可能做的不太完善，还有好多情况没有实验，觉得意义也不大。简单总结一下运行的顺序。 首先执行try中的代码，如果有return，则保存住return的值后再执行finally的代码，如果finally中有return，那么则执行finally的return，如果finally中没有return，则执行完finally代码后，会再执行try中的return，返回的值是之前在try中保存的值。ca...
当try,catch,finally中均有return语句时，会返回哪一个？---finally中的return
weixin_33898233的博客
01-16 518
2019独角兽企业重金招聘Python工程师标准>>> ...
try , catch , finally 中带有 return 时的执行顺序
qq_49044908的博客
03-31 2173
https://www.cnblogs.com/pcheng/p/10968841.html
try-catch-finally-return-in-finally.rar_return
09-21
这意味着，如果在 `finally` 块中有 `return`，那么这个 `return` 将覆盖之前 `try` 或 `catch` 中的 `return`，成为函数的最终返回值。 例如，在JavaScript中，以下示例展示了 `try-catch-finally-return-in-...
try、catch、finally、return 执行顺序.doc
09-09
try、catch、finally、return 执行顺序的规则是：try 语句用于包装可能抛出异常的代码，catch 语句用于捕捉 try 语句中的异常，finally 语句用于执行一些清理工作，return 语句用于从方法中返回值。finally 语句是在...
try catch finally的执行顺序深入分析
09-05
在这个过程中，函数会将`try`或`catch`块中的`return`语句返回的值暂存起来，然后执行`finally`块。 如果在`finally`块中也有`return`语句，那么这个`return`值会覆盖之前暂存的值。也就是说，最终返回给调用者的值...
Java中finally和return的关系实例解析
08-28
这意味着，如果在try块中执行了return语句，finally语句将在return语句执行之前执行。如果finally语句中包含了return语句，即使前面的catch块重新抛出了异常，则调用该方法的语句也不会获得catch块重新抛出的异常，...
try catch 语句中有return 的各类情况
hello_world_he的博客
09-03 2899
首先对于出入java的人来说，java异常体系肯定有所接触，也听说过一个一个方法的结束以return 语句为标志。还有便是对于finally语句块无论是否出现异常都会执行，但是当try catch 语句中有return的时候对于新手来说肯定有一些疑惑，对于我来说里面的指令到底是怎么执行的我也是不是太清楚，但是我基本上可以判断执行结果了，这对于程序开发以及出现面试的面试题已经足够了。 首先说结论：...
有return的情况下try catch finally的执行顺序（最有说服力的总结）
热门推荐
我只是坚持我的兴趣。
10-13 23万+
结论： 1、不管有木有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行； 3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的； 4、finally
有返回值的函数，如果包含try/catch块，经常会出现没有return的错误
weixin_30565199的博客
06-22 382
public static Connection getConnection(){ try { return datasource.getConnection(); } catch (SQLException e) { //这里得用运行时异常。不然就会报没有return的错误 System.out.println(e); throw new RuntimeExcep...
try catch 中 return 详解
xuedengyong的博客
02-06 6893
只代表个的一些看法，如有不对请多多指教！         by    xue.kevin        看了好多人的解释，觉得都不太准确，其实大家都陷入了一个误区，return XXX；这句代码的意思不是说返回 XXX这个对象，而是返回 当前 XXX所指向的物理地址，如果return没有立即执行，那么无论什么时候，这个return记录的返回值是不会变的（因为java不支持对内存的操作，所以我也无
Java中try-catch-finally-return的执行顺序
qq_34501351的博客
11-27 311
本文转自撒法第 1. try块中没有抛出异常，try、catch和finally块中都有return语句 public static int NoException(){ int i=10; try{ System.out.println("i in try block is："+i); return --i; ...
基于微信小程序的新生报到系统设计与实现.docx
09-13
基于微信小程序的新生报到系统设计与实现.docx
基于java的电商平台的设计与实现.docx
最新发布
09-13
基于java的电商平台的设计与实现.docx
基于java的大学生智能消费记账系统的设计与实现.docx
09-13
基于java的大学生智能消费记账系统的设计与实现.docx
深入理解try-catch-finally-return的执行顺序与返回值
本文档详细探讨了Java编程中`try-catch-finally`语句块的执行顺序以及`return`语句在其中的作用。首先，重要的一点是无论是否发生异常，`finally`块中的代码始终会被执行，确保其中的清理工作得以完成。即使`try`和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值