try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后？

try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，会执行的，会在return执行前执行的。比如执行到return还没有执行return时候，程序会先执行finally然后再执行return

1. 当有finally语句并且try中有return，在执行到return（还未执行）的时候，会先执行finally里面的内容，然后再执行行try中的return。

1. package com.and.java.demo;
   
2. 
   
3. public class 测试 {
   
4.     public static void main(String[] args) {
   
5.         System.out.println(new 测试().test());
   
6.     }
   
7. 
   
8.     public String test() {
   
9.         try {
   
10.             System.out.println("try{...}");
    
11.             return "try";
    
12.         } catch (Exception e) {
    
13.             System.out.println("catch{...}");
    
14.             return "catch";
    
15.         } finally {
    
16.             System.out.println("finally{...}");
    
17.         }
    
18.     }
    
19. }

复制代码

输出：
try{...}
finally{...}
try

2、在1的基础上，如果finally里面也有return语句，则try代码块中的return被屏蔽（不执行），即在try中遇到return的时候，会先执行finally里面的内容（包括finally里面的return语句）。

1. package com.and.java.demo;
   
2. 
   
3. public class 测试 {
   
4.     public static void main(String[] args) {
   
5.         System.out.println(new 测试().test());
   
6.     }
   
7. 
   
8.     public String test() {
   
9.         try {
   
10.             System.out.println("try{...}");
    
11.             return "try";
    
12.         } catch (Exception e) {
    
13.             System.out.println("catch{...}");
    
14.             return "catch";
    
15.         } finally {
    
16.             System.out.println("finally{...}");
    
17.             return "finally";
    
18.         }
    
19.     }
    
20. }

复制代码

输出：
try{...}
finally{...}
finally

在try{}...catch(){}...finally{}中，finally里面的语句是永远都执行的，一般在try catch执行完后再执行finally里面的语句。
但如果在前面遇到跳转 例如：return 语句时，finally中的语句会在return执行前执行。
这样做的原因是：在执行try catch的代码的时候，可能导致系统异常结束，或者跳转到另一个对象上，这样就可能导致系统资源没有关闭。
finally总是执行和在return前执行就避免了这个问题的发生。

关于楼主的问题：当遇到前面的try中有return时，finally里面的语句是否会执行，答案是会执行，而且会在return语句的前面执行

1. ublic class TryCatch {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) throws Exception {
   
7.                 // TODO Auto-generated method stub
   
8.                 System.out.println(fun());
   
9.         }
   
10. 
    
11.         public static int fun() throws Exception {
    
12.                 int a = 1;
    
13.                 try {
    
14.                         return a++;
    
15.                 } finally {
    
16.                         ++a;
    
17.                 }
    
18.         }
    
19. 
    
20. }

复制代码

这是一个插入执行顺序，如果是顺序执行的话， 那么它的结果就会改变
可以将try中的值和finally的值看做2个不同类型的a，
try的代码中有return时，finally中的代码同样会执行，会在它之前执行。但是上面的列子，你可以看做它们在内存中操作的不是同一个变量

1. class MyTest{
   
2.     public static String func(){
   
3.         try{
   
4.             System.out.println("try里跳转前的语句");
   
5.             return "try";
   
6.         }catch(Exception e){
   
7.             System.out.println("异常处理语句");
   
8.         }finally{
   
9.             System.out.println("finally语句");
   
10.         }
    
11.         return "over";
    
12.     }
    
13. }
    
14. public class MyDemo{
    
15.     public static void main(String[] args){
    
16.         System.out.println(MyTest.func());
    
17.     }
    
18. }
    

复制代码

输出结果是：
try里跳转前的语句
finally语句
try

finally里的语句是一定会执行的，除非它也发生异常无法执行，那就要继续try咯
而finally里的语句执行是在try里的跳转之前的，原因是保证异常处理完成前，不会出现意外。
一般我们会在finally里关闭系统资源，而如果finally执行在跳转后的话，那就可能导致资源无法正常关闭。
（跳转后面不会有语句的，因为执行不到嘛，嘿嘿，不过这个好像大家都知道的）