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

try()里面有return语句，程序执行try()的时候，如果运行到有异常的代码，先执行catch()，在catch()中处理异常。当执行到return的时候，跳出try()代码块儿，然后执行finally中的代码，最后程序停止运行。finally代码块儿中的代码一定会运行。

首先，finally里的语句无论try-catch语句是否会发生异常，一定会执行的，除非语句中用了System.exit(0)。如果try语句中有return语句，那么finally语句会是什么时候执行，我们可以编写一段代码进行验证，如下

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 // TODO Auto-generated method stub
   
5.                 System.out.println(test());
   
6.         }
   
7.         public static boolean test(){
   
8.                 try{
   
9.                         return result1();
   
10.                 }finally{
    
11.                         result2();
    
12.                 }
    
13.         }
    
14.         public static boolean result1(){
    
15.                 System.out.println("It's reuturn");
    
16.                 return true;
    
17.         }
    
18.         public static void result2(){
    
19.                 System.out.println("It's finally");
    
20.         }
    
21. }

复制代码

执行结果如下
"It's reuturn"
"It's finally"
true

以上结果说明，return首先被执行，finally后被执行，return并不是让结果马上返回，而是先把结果放到函数中，然后必须等待finally结果出来后再返回

......
try {
    return "csdn";
}
finally {
     System.out.println("close!!!");
}
这个finally里面的输出语句是必须执行的，只有当下面的情况finally里面的代码执行不了：
try {
    .......
    return "csdn";
    System.exit(0);//直接将jvm关了！！！
}
finally
{
     System.out.println("close!!!");//这里执行不到！！！
}

try catch 成对出现的，一个try就一定要有catch，被try包裹的代码说明，如果这些代码中只要抛出异常的话，就会停止当前的代码运行，而跳到catch中，对于异常进行处理。
而finally呢，他是一个比较特殊的东西，finally中的代码无论出现说明状况都会运行到。即使出现异常。所以finally一般都是处理对资源的释放等操作。
try{
          go(); //假设在调用go方法的时候发生的异常
      return “hello”; //这个return语句都是无法执行到的。
}catch(Exception e){
         System.out.println("发生的异常了！");
}finally{
         System.out.println("这里一定回执行！");
}
希望能帮到你~

无论try里有一个return语句，还是catch里有return都是会执行finally里的语句的，如果是没有抛出异常那就是执行完try里的return以后执行finally里的语句，如果抛出了异常那就执行完catch中的return语句执行finally里的语句

finally 里面的语句肯定会执行的 。  不管 try 里面return 还是 出现异常。 都会执行的
return首先被执行，finally后执行。
return并不是马上返回结果，而是先把结果放在函数中，
然后等待finally结果出来后才真正的返回。

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                
   
4.                 System.out.println(test());
   
5.         }
   
6.        
   
7.         public static int test(){
   
8.                 try{
   
9.                         return testTry();
   
10.                 }
    
11.                 finally{
    
12.                         testFinally();
    
13.                 }
    
14.         }
    
15. 
    
16.         private static int testTry() {
    
17.                 System.out.println("testTry执行");
    
18.                 return 1;
    
19.         }
    
20. 
    
21.         private static void testFinally() {
    
22.                 System.out.println("testFinally执
    
23. 
    
24. 行");
    
25.         }
    
26. 
    
27. }

复制代码

执行结果：
try执行
finally执行
1

所以return首先被执行，finally后执行。
return并不是马上返回结果，而是先把结果放在函数中，
然后等待finally结果出来后才真正的返回。

finally{}  中的代码是肯定会被执行的代码，无论是异常还是跳出，都会先执行这里面的代码
可以通过下面代码的运行结果看到 你想知道的结果，时先执行 finally 再执行 return后的代码

互相学习！

1. class TryCatchTest
   
2. {
   
3.                         public static void main(String[] args)
   
4.                         {
   
5.                                         TryCatch();
   
6.                                         System.out.println("Return ...");
   
7.                         }
   
8.                        
   
9.                         public static void TryCatch()
   
10.                         {
    
11.                                 try
    
12.                                         {
    
13.                                                         if(true)
    
14.                                                                         return;
    
15.                                         }
    
16.                                         finally
    
17.                                         {
    
18.                                                                 System.out.println("Finally ...");
    
19.                                         }
    
20.                                        
    
21.                         }
    
22. 
    
23. }

复制代码

先结合一个小例子分析一下吧

1. package cn.itheima;
   
2. 
   
3. public class tryFinallyDemo {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 System.out.println(test());//step1：调用test()方法
   
7.                                            //step7：将返回的i的值(i=5)打印在控制台
   
8.         }
   
9.         public static int test() {
   
10.                 int i = 2; //step2:创建i变量并赋值2；
    
11.                 try {
    
12.                         i+=3; //step3：i自加3；即现在i=5;
    
13.                         return i; //step4:执行return语句，将i的值保存在缓冲区；
    
14.                                   //step6:将保存在缓冲区的i值返回；
    
15.                 } finally {
    
16.                         i+=3; //step5:i自加3;即现在i=8;
    
17.                 }
    
18.         }
    
19. }

复制代码

总结：
try 和finally的执行顺序问题：
程序会先执行try的语句，如果try遇到exception或者error后，执行catch中的语句，最后执行finally中的语句
程序在try中遇到return语句后，会将return的结果存在一个缓存中，但是并不会直接就输出，而是先储存起来，等到finally执行完毕后才输出return结果，接入finally中也有return语句，那么就会覆盖掉try中的return值
希望对你有帮助！