关于Java中try-catch-finally-return的执行顺序

最新推荐文章于 2023-10-19 10:53:19 发布
最新推荐文章于 2023-10-19 10:53:19 发布
阅读量188 收藏
点赞数
分类专栏： JAVA 文章标签： try..catch..finally

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返回的。


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返回的。


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
===============================


总体结论：

结论一：

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

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

yinghuolsx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java异常捕获之try-catch-finally-return的执行顺序
chrdww的博客
08-07 205
情况1：try块中没有抛出异常try和finally块中都有return语句 public static int NoException(){ int i=10; try{ System.out.println("i in try block is"+i); return --i; }catch(Exception e){ ...
try-catch-finally中return的执行情况
leokelly001的专栏
01-11 706
在try中没有异常的情况下try、catch、finally的执行顺序 try --- finally 如果try中有异常，执行顺序是try --- catch --- finally 如果try中没有异常并且try中有return这时候正常执行顺序是try ---- finally --- return 如果try中有异常并且try中有return这时候正常执行顺序是try----
JAVA中try、catch、finally带return的执行顺序总结
weixin_45504270的博客
07-07 183
1、finally中的代码总会被执行。 2、当try、catch中有return时，也会执行finally。return的时候，要注意返回值的类型，是否受到finally中代码的影响。 3、finally中有return时，会直接在finally中退出，导致try、catch中的return失效。 ...
try-catch-finally-return 的执行顺序
ratel的博客
11-17 803
结论： 1、不管有没有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行； 3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的； 4、finally中最好...
谈谈Java中try-catch-finally中的return语句
09-02
在Java编程语言中，`try-catch-finally`语句块是异常处理的关键构造，它允许程序员优雅地处理可能出现的异常情况。`return`语句则用于从方法中返回一个值或者结束方法的执行。当这两者结合在一起时，就会出现一些...
关于Java中的try-catch-finally语句和return
12-22
第一：return语句并不是函数的终出口，如果有finally语句，这在return之后还会执行finally（return的值会暂存在栈里面，等待finally执行后再返回） 　第二：finally里面不建议放return语句，根据需要，return语句...
try-catch-finally执行顺序验证
01-20
try-catch-finally执行顺序验证(左边是.java文件，右边是.class文件) 提示： try、catch块内的return操作编译后会变成把return的值保存到变量var的操作。 总结: try、catch块内的return操作编译后会变成把return的值...
关于Java中try finally return语句的执行顺序浅析
08-29
关于Java中try finally return语句的执行顺序浅析是Java语言中一个重要的知识点，今天我们来探讨一下try finally return语句的执行顺序。 首先，需要了解的是finally语句块是否一定会执行的问题。很多人第一反应是...
try-catch-finally-return-in-finally.rar_return
09-21
标题 "try-catch-finally-return-in-finally.rar_return" 提到了 `try-catch-finally` 结构与 `return` 语句的交互，这涉及到程序执行流程的关键方面。 `try` 块是用来包含可能会抛出异常的代码。如果在 `try` 块中...
try、catch、finally、return 执行流程——超详细讲解
lcz1999923的博客
06-09 2509
打开CSDN APP Copyright 1999-2020, CSDN.NET, All Rights Reserved HarmonyOS 开源开放毫无保留 登录 薛瑄 关注 try、catch、finally、return 执行顺序——超详细讲解 原创 2015-12-11 18:37:23 17点赞 薛瑄 码龄9年 关注 你也可以查看我的其他同类文章，也会让你有一定的收货！ 代码示例：http://www.cnblogs.com/lanxuezaipiao/p/3440...
Java 关于try,catch,finally有return的时候
w359677142的博客
08-15 299
先说下关于他们的一个执行情况，try,catch什么情况就不说了，在什么情况运行这个都知道，finally 也是一样的不管程序有没有错误也会执行。现在主要就是一个执行顺序的问题。 下面一段代码来引入 public static String fun() { try { //int a=1/0; System.out.println("111111111"); return...
try catch finally和return的执行顺序
一个人的Code博客
10-19 610
程序先执行try，如果遇到异常执行catch块， 有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，最后执行catch块中return. finally之后也就是4处的代码不再执行。最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的。
JAVA的异常处理机制（一）——try...catch...finally
Alexwym的博客
07-27 2707
在编程语言中，异常定义了程序中遇到的非致命的错误，比如，程序要打开一个不存的文件、网络连接中断、除零操作、操作数越界、装载一个不存在的类等情况。这些异常错误往往会导致程序中断，无法正常执行。异常处理机制可以防止程序在出现异常时直接崩溃。它可以让程序继续执行，并且处理相应的错误（比如：打印出错误信息等）。今天我们就来看一下JAVA的异常处理机制。 一、基本格式 try { ...
有return的情况下try catch finally的执行顺序（最有说服力的总结）
热门推荐
我只是坚持我的兴趣。
10-13 23万+
结论： 1、不管有木有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行； 3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的； 4、finally
try catch 中的异常怎么处理?
06-26 8179
轻松弄懂咋用 try catch
深入理解try catch吃掉异常，及catch（Exception e）中的异常
小爷欣欣
11-28 7万+
package test.s; public class yichang { public static void main(String[] args) throws Exception{ try{ double a=aa(); System.out.println(a); }catch(Exception e){ e.printStackTrace(); }
JavaSE之彻底搞懂try,catch,finally与return的执行
狼王神起的博客
04-01 1万+
  在开始我的博客之前，我先引用马士兵老师的一句话，掌握了内存你就掌握了一切（滑稽）。         一般情况下，程序执行到try里面的内容一定会执行finally里面的内容。如果在try或者catch里面遇到return，那么函数在执行完return后面的表达式之后，会先去执行finally里面的语句块，然后再结束方法体。但有一种特殊情况，如果在try里面有System.exit(0)这样的语...
关于try、catch、finally中return的执行顺序
chenruijia170707的博客
11-17 631
try、catch、finally中的return顺序和有效性声明：参考资料来源 http://blog.csdn.net/wangqingbo0829/article/details/52458283，本人出于学习，收集干货，不作商业用途！今天面试的时候，被问到这个return的执行结果和顺序，发现自己有些遗忘了，于是回来赶紧查一下相关的资料，看到这篇文章写得很好 http://blog.csd
try-catch-finally-return执行顺序
最新发布
11-22
try-catch-finally-return执行顺序如下： 1.程序先执行try块中的代码。 2.如果try块中的代码出现异常，则跳转到catch块中执行相应的代码。 3.如果catch块中有return语句，则执行return之前（包括return语句中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值