Java finally语句到底是在return之前还是之后执行？

最新推荐文章于 2022-04-07 18:10:47 发布
最新推荐文章于 2022-04-07 18:10:47 发布
阅读量505 收藏
点赞数
分类专栏： Java

网上有很多人探讨Java中异常捕获机制try...catch...finally块中的finally语句是不是一定会被执行？很多人都说不是，当然他们的回答是正确的，经过我试验，至少有两种情况下finally语句是不会被执行的：

（1）try语句没有被执行到，如在try语句之前就返回了，这样finally语句就不会执行，这也说明了finally语句被执行的必要而非充分条件是：相应的try语句一定被执行到。

（2）在try块中有System.exit(0);这样的语句，System.exit(0);是终止Java虚拟机JVM的，连JVM都停止了，所有都结束了，当然finally语句也不会被执行到。


当然还有很多人探讨Finally语句的执行与return的关系，颇为让人迷惑，不知道finally语句是在try的return之前执行还是之后执行？我也是一头雾水，我觉得他们的说法都不正确，我觉得应该是：finally语句是在try的return语句执行之后，return返回之前执行。这样的说法有点矛盾，也许是我表述不太清楚，下面我给出自己试验的一些结果和示例进行佐证，有什么问题欢迎大家提出来。


1. finally语句在return语句执行之后return返回之前执行的。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FinallyTest1 { 
  2.  
  3.     public staticvoid main(String[] args) { 
  4.          
  5.         System.out.println(test1()); 
  6.     } 
  7.  
  8.     public staticint test1() { 
  9.         int b = 20; 
  10.  
  11.         try { 
  12.             System.out.println("try block"); 
  13.  
  14.             return b += 80;  
  15.         } 
  16.         catch (Exception e) { 
  17.  
  18.             System.out.println("catch block"); 
  19.         } 
  20.         finally { 
  21.              
  22.             System.out.println("finally block"); 
  23.              
  24.             if (b > 25) { 
  25.                 System.out.println("b>25, b = " + b); 
  26.             } 
  27.         } 
  28.          
  29.         return b; 
  30.     } 
  31.      
  32. }  
public class FinallyTest1 {

	public static void main(String[] args) {
		
		System.out.println(test1());
	}

	public static int test1() {
		int b = 20;

		try {
			System.out.println("try block");

			return b += 80; 
		}
		catch (Exception e) {

			System.out.println("catch block");
		}
		finally {
			
			System.out.println("finally block");
			
			if (b > 25) {
				System.out.println("b>25, b = " + b);
			}
		}
		
		return b;
	}
	
}

运行结果是：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. try block 
  2. finally block 
  3. b>25, b = 100 
  4. 100  
try block
finally block
b>25, b = 100
100
说明return语句已经执行了再去执行finally语句，不过并没有直接返回，而是等finally语句执行完了再返回结果。

如果觉得这个例子还不足以说明这个情况的话，下面再加个例子加强证明结论：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FinallyTest1 { 
  2.  
  3.     public staticvoid main(String[] args) { 
  4.          
  5.         System.out.println(test11()); 
  6.     } 
  7.      
  8.     public static String test11() { 
  9.         try { 
  10.             System.out.println("try block"); 
  11.  
  12.            return test12(); 
  13.       } finally { 
  14.            System.out.println("finally block"); 
  15.        } 
  16.   } 
  17.  
  18.   public static String test12() { 
  19.        System.out.println("return statement"); 
  20.  
  21.        return "after return"; 
  22.    } 
  23.      
  24. }  
public class FinallyTest1 {

	public static void main(String[] args) {
		
		System.out.println(test11());
	}
	
	public static String test11() {
        try {
            System.out.println("try block");

           return test12();
      } finally {
           System.out.println("finally block");
       }
  }

  public static String test12() {
       System.out.println("return statement");

       return "after return";
   }
	
}
运行结果为：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. try block 
  2. return statement 
  3. finally block 
  4. after return  
try block
return statement
finally block
after return

说明try中的return语句先执行了但并没有立即返回，等到finally执行结束后再

这里大家可能会想：如果finally里也有return语句，那么是不是就直接返回了，try中的return就不能返回了？看下面。


2. finally块中的return语句会覆盖try块中的return返回。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FinallyTest2 { 
  2.  
  3.     public staticvoid main(String[] args) { 
  4.  
  5.         System.out.println(test2()); 
  6.     } 
  7.  
  8.     public staticint test2() { 
  9.         int b = 20; 
  10.  
  11.         try { 
  12.             System.out.println("try block"); 
  13.  
  14.             return b += 80; 
  15.         } catch (Exception e) { 
  16.  
  17.             System.out.println("catch block"); 
  18.         } finally { 
  19.  
  20.             System.out.println("finally block"); 
  21.  
  22.             if (b > 25) { 
  23.                 System.out.println("b>25, b = " + b); 
  24.             } 
  25.  
  26.             return 200; 
  27.         } 
  28.  
  29.         // return b; 
  30.     } 
  31.  
  32. }  
public class FinallyTest2 {

    public static void main(String[] args) {

        System.out.println(test2());
    }

    public static int test2() {
        int b = 20;

        try {
            System.out.println("try block");

            return b += 80;
        } catch (Exception e) {

            System.out.println("catch block");
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            return 200;
        }

        // return b;
    }

}

运行结果是：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. try block 
  2. finally block 
  3. b>25, b = 100 
  4. 200  
try block
finally block
b>25, b = 100
200

这说明finally里的return直接返回了，就不管try中是否还有返回语句，这里还有个小细节需要注意，finally里加上return过后，finally外面的return b就变成不可到达语句了，也就是永远不能被执行到，所以需要注释掉否则编译器报错。

这里大家可能又想：如果finally里没有return语句，但修改了b的值，那么try中return返回的是修改后的值还是原值？看下面。


3. 如果finally语句中没有return语句覆盖返回值，那么原来的返回值就不会因为finally里的修改而改变。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FinallyTest3 { 
  2.  
  3.     public staticvoid main(String[] args) { 
  4.  
  5.         System.out.println(test3()); 
  6.     } 
  7.  
  8.     public staticint test3() { 
  9.         int b = 20; 
  10.  
  11.         try { 
  12.             System.out.println("try block"); 
  13.  
  14.             return b += 80; 
  15.         } catch (Exception e) { 
  16.  
  17.             System.out.println("catch block"); 
  18.         } finally { 
  19.  
  20.             System.out.println("finally block"); 
  21.  
  22.             if (b > 25) { 
  23.                 System.out.println("b>25, b = " + b); 
  24.             } 
  25.  
  26.             b = 150; 
  27.         } 
  28.  
  29.         return 2000; 
  30.     } 
  31.  
  32. }  
public class FinallyTest3 {

    public static void main(String[] args) {

        System.out.println(test3());
    }

    public static int test3() {
        int b = 20;

        try {
            System.out.println("try block");

            return b += 80;
        } catch (Exception e) {

            System.out.println("catch block");
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            b = 150;
        }

        return 2000;
    }

}

运行结果是：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. try block 
  2. finally block 
  3. b>25, b = 100 
  4. 100  
try block
finally block
b>25, b = 100
100
finally里的b = 150;并没有起到作用，这貌似是前面说的有些矛盾，因为前面说try中的return是在finally执行完了才返回的，这里我的解释是：因为try中的return语句已经执行完了只是还没有返回，但是它的返回值已经确定下来了（这里是100），已经跟b这个变量无关了，不会再根据b的值决定返回什么，所以finally里对b的修改只影响b的值对原来已脱离b影响的返回值没有一点影响。这同时也说明了返回语句是try中的return语句而不是finally外面的return b;这句，不相信的话可以试下，将return b;改为return 294，对原来的结果没有一点影响。

这里大家可能又要想：是不是每次返回的一定是try中的return语句呢？那么finally外的return b不是一点作用没吗？请看下面。


4. try块里的return语句在异常的情况下不会被执行，这样具体返回哪个看情况。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FinallyTest4 { 
  2.  
  3.     public staticvoid main(String[] args) { 
  4.  
  5.         System.out.println(test4()); 
  6.     } 
  7.  
  8.     public staticint test4() { 
  9.         int b = 20; 
  10.  
  11.         try { 
  12.             System.out.println("try block"); 
  13.  
  14.             b = b / 0; 
  15.  
  16.             return b += 80; 
  17.         } catch (Exception e) { 
  18.  
  19.             b += 15; 
  20.             System.out.println("catch block"); 
  21.         } finally { 
  22.  
  23.             System.out.println("finally block"); 
  24.  
  25.             if (b > 25) { 
  26.                 System.out.println("b>25, b = " + b); 
  27.             } 
  28.  
  29.             b += 50; 
  30.         } 
  31.  
  32.         return 204; 
  33.     } 
  34.  
  35. }  
public class FinallyTest4 {

    public static void main(String[] args) {

        System.out.println(test4());
    }

    public static int test4() {
        int b = 20;

        try {
            System.out.println("try block");

            b = b / 0;

            return b += 80;
        } catch (Exception e) {

            b += 15;
            System.out.println("catch block");
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            b += 50;
        }

        return 204;
    }

}
运行结果是：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. try block 
  2. catch block 
  3. finally block 
  4. b>25, b = 35 
  5. 85  
try block
catch block
finally block
b>25, b = 35
85

这里因为在return之前发生了除0异常，所以try中的return不会被执行到，而是接着执行捕获异常的catch语句和最终的finally语句，此时两者对b的修改都影响了最终的返回值，这时return b;就起到作用了。当然如果你这里将return b改为return 300什么的，最后返回的就是300，这毋庸置疑。

这里大家可能又有疑问：如果catch中有return语句呢？当然只有在异常的情况下才有可能会执行，那么是在finally之前就返回吗？看下面。


5. 当发生异常后，catch中的return执行情况与未发生异常时try中return的执行情况完全一样。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FinallyTest5 { 
  2.  
  3.     public staticvoid main(String[] args) { 
  4.  
  5.         System.out.println(test5()); 
  6.     } 
  7.  
  8.     public staticint test5() { 
  9.         int b = 20; 
  10.  
  11.         try { 
  12.             System.out.println("try block"); 
  13.              
  14.             b = b /0; 
  15.  
  16.             return b += 80; 
  17.         } catch (Exception e) { 
  18.  
  19.             System.out.println("catch block"); 
  20.             return b += 15; 
  21.         } finally { 
  22.  
  23.             System.out.println("finally block"); 
  24.  
  25.             if (b > 25) { 
  26.                 System.out.println("b>25, b = " + b); 
  27.             } 
  28.  
  29.             b += 50; 
  30.         } 
  31.  
  32.         //return b; 
  33.     } 
  34.  
  35. }  
public class FinallyTest5 {

	public static void main(String[] args) {

		System.out.println(test5());
	}

	public static int test5() {
		int b = 20;

		try {
			System.out.println("try block");
			
			b = b /0;

			return b += 80;
		} catch (Exception e) {

			System.out.println("catch block");
			return b += 15;
		} finally {

			System.out.println("finally block");

			if (b > 25) {
				System.out.println("b>25, b = " + b);
			}

			b += 50;
		}

		//return b;
	}

}

运行结果如下：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. try block 
  2. catch block 
  3. finally block 
  4. b>25, b = 35 
  5. 35  
try block
catch block
finally block
b>25, b = 35
35

说明了发生异常后，catch中的return语句先执行，确定了返回值后再去执行finally块，执行完了catch再返回，finally里对b的改变对返回值无影响，原因同前面一样，也就是说情况与try中的return语句执行完全一样。


最后总结：finally块的语句在try或catch中的return语句执行之后返回之前执行且finally里的修改语句不能影响try或catch中return已经确定的返回值，若finally里也有return语句则覆盖try或catch中的return语句直接返回。

梦想一直都在
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Java finally语句到底是在return之前还是之后执行(必看篇)
08-30
那么，finally 语句是在 try 的 return 之前还是之后执行的呢？这个问题引起了很多人的探讨和争论。通过实验和示例，我们可以证明 finally 语句是在 try 的 return 语句执行之后，return 返回之前执行的。 在下面的...
java AfterReturning 处理回调
最新发布
一路向前
08-07 538
如果要进行回调，内容都相似，可以考虑用注解@AfterReturnning去处理。如果实现的内容都不相同，可以考虑定义个统一回调接口，不同类去实现该方法去处理。
java 自定义AfterReturning切面注解
恨_别离的博客
04-07 4858
自定义一个注解并实现注解返回后处理逻辑功能 自定义一个注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface CommunityOperation { /** * 主键 */ String id() default "id"; /** * 类型 */ ContentTypeEnum type();
try{}catch{}finally{}的return执行逻辑
xilin6664的博客
01-08 211
try{}catch{}finally{}代码块里面都有return: public class DemoTest { public static void main(String[] args) { int num = getNum(); System.out.println("执行结果: " +num); } public static int getNum() { int i; try {
try、catch、finally中包含return的执行结果总结
Ethan_199402的博客
05-19 276
1、不管有没有出现异常，finally块中代码都会执行，即所谓的finally块中是无论如何都会执行的代码 2、当try和catch中有return时，finally仍然会执行在return结果返回之前，但是此时try或者catch里面return后面的表达式已经执行完毕，结果存在栈中； 3、当try和catch中有return时： 若返回的是基本类型或者字符串类型，在finally里面对返回值重新赋值，不影响返回结果 若返回值类型是引用类型，此时要明白上述第二条中保存在栈中的结果是该引用类型变量的引用地址
Java语言finally语句详解,finally到底是在return之前还是之后执行.zip
01-11
Java语言finally语句详解,finally到底是在return之前还是之后执行.zip
关于Java中try finally return语句的执行顺序浅析
08-29
还有情况是当一个线程在执行try语句块或者catch语句块时被打断(interrupted)或者被终止(killed)，与其对应的finally语句块可能不会执行。还有更极端的情况，就是在线程运行try语句块或者catch语句块时，突然死机或者...
Java异常处理中同时有finally和return语句的执行问题
09-03
首先，`finally`块中的代码总是会被执行，除非程序在执行到`finally`块之前就退出了JVM（例如通过`System.exit()`）。即使在`try`块或`catch`块中有`return`语句，`finally`块内的代码也会在返回之前被执行。这是...
java 中finally语句块与return的执行关系
04-11
在 Java 规范中规定，在 try-catch-finally 中，如果 try-finally 或者 catch-finally 中都有 return，则两个 return 语句都执行，并且最终返回到调用者那里的是 finally 中 return 的值；而如果 finally 中没有 ...
Java中finally和return的关系实例解析
08-28
finally语句是在try的return语句执行之后，return返回之前执行的。这意味着，如果在try块中执行了return语句，finally语句将在return语句执行之前执行。如果finally语句中包含了return语句，即使前面的catch块重新抛...
完全解析Java编程中finally语句的执行原理
09-03
举个例子，当`try`语句块在执行前就返回了（`return`语句）或抛出了异常，如果`try`块没有被执行，相应的`finally`块也不会执行。在清单1的示例中，由于`i = i / 0`导致了`ArithmeticException`，程序在进入`try`块...
关于Java中的try-catch-finally语句和return
12-22
第一：return语句并不是函数的终出口，如果有finally语句，这在return之后还会执行finally（return的值会暂存在栈里面，等待finally执行后再返回） 　第二：finally里面不建议放return语句，根据需要，return语句...
谈谈Java中try-catch-finally中的return语句
09-02
在Java编程语言中，`try-catch-finally`语句块是异常处理的关键构造，它允许程序员优雅地处理可能出现的异常情况。`return`语句则用于从方法中返回一个值或者结束方法的执行。当这两者结合在一起时，就会出现一些...
try，catch，finally结构中return的返回值
chen404897439的博客
02-28 1099
实验可能做的不太完善，还有好多情况没有实验，觉得意义也不大。简单总结一下运行的顺序。 首先执行try中的代码，如果有return，则保存住return的值后再执行finally的代码，如果finally中有return，那么则执行finally的return，如果finally中没有return，则执行完finally代码后，会再执行try中的return，返回的值是之前在try中保存的值。ca...
关于try_catch_finally里面return等问题的结论
王文强的博客
08-25 416
结论： 1、不管有木有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行； 3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的； 4、finally中最好不...
Java中finally与return的执行顺序
骏马逸动，心随你动的博客
03-24 8190
在Java的异常处理中，try、catch 和 finally 是按顺序执行的。如果 try 中没有异常，则顺序为 try→finally，如果 try 中有异常，则顺序为 try→catch→finally。但是当 try、catch、finally 中加入 return 之后，return 和 finally 的执行顺序让很多人混淆不清。下面来分别说明一下。 1. try 和 catch 中带有return 1）try 中带有 return public class tryDemo { ...
@AfterReturning配置
z69183787的专栏
01-07 9008
AfterReturning和before，after，around不同是可以获取织入函数的返回值，配置复杂一点。 如果切入点如下： [java] view plaincopyprint? package com.leanyu.lcsystem.pointcut;      import org.aspectj.lang.annotat
java中return应该在try中还是在catch中还是在finally中
05-03
在Java中，`return`语句应该放在`try`或`catch`块之外，而不是在`finally`块中。在`finally`块中使用`return`语句会导致一些意外的行为，因为`finally`块中的代码总是会被执行，无论是否有异常抛出或`return`语句。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值