在try中写了return，后面又写了finally，是先执行return还是先执行fianlly？

public class Test5 {

       
        public static void main(String[] args) {
                //调用test方法并输出
                System.out.println("test:"+test());
        }
        //创建个有返回的方法来证明
        public static int test(){
                //定义一个变量a
                int a = 1;
                //证明try后面有return和finally先执行谁
                try{
                        System.out.println("try:"+a);
                        //返回a的值
                        return a;
                }finally{
                        //从新定义一个a的值
                        a=5;
                        System.out.println("finally:"+a);
                }
        }

}
你可以自己运行下试试

执行完  return   就不执行 finally   了

一般的情况下，finally后是一定要执行的铁打不动的.....
对于try中有return的，是先finally，后return
过去在哪看过个比较给力的代码段，似乎是下面这样的

1. public class Test {
   
2. 
   
3.   public static void main(String[] args) throws Exception {
   
4.     System.out.println(fin());
   
5.   }
   
6. 
   
7.   static int fin() throws Exception {
   
8.     try {
   
9.       System.out.println("我要被执行");
   
10.       //System.exit(1);//强制退出后是无法return，finally什么的
    
11.       System.out.println("我能被执行？(1)");
    
12.       return 0;
    
13.     } finally {
    
14.       System.out.println("我能被执行？");
    
15.     }
    
16.   }
    
17. }

复制代码

执行结果：我要被执行
我能被执行？(1)
我能被执行？
0

加上注释部分，执行结果：我要被执行

先执行try中的代码，再执行finally中代码。要是都有return，那么返回的是finally中的值。如下代码

1. public static void main(String[] args){
   
2.                 //打印结果为19，说明先执行了try中的代码，将9赋值给x，再执行finally中代码,跟10相加。最终方法返回的是finally中return的结果
   
3.                 System.out.println(get());
   
4.         }
   
5.         public static int get(){
   
6.                 int x = 0 ;
   
7.                 try {
   
8.                         x = 9 ;
   
9.                         return 6 ;               
   
10.                 } catch (Exception e) {
    
11.                         e.toString();
    
12.                 }
    
13.                 finally{
    
14.                         return 10+ 9 ;
    
15.                 }
    
16.         }

复制代码

1. class Demo02 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 String str = method_01();
   
5.                 System.out.println(str);
   
6.         }
   
7.         
   
8.         public static String method_01() {
   
9.                 try {
   
10.                         System.out.println("method_01() 方法被调用");
    
11.                         return method_02();
    
12.                 } finally {
    
13.                         System.out.println("method_01() finally { }");
    
14.                 }
    
15.         }
    
16.         
    
17.         public static String method_02() {
    
18.                 System.out.println("method_02() 方法被调用");
    
19.                 return "abc";
    
20.         }
    
21.         
    
22. }

复制代码

结果为：
method_01() 方法被调用
method_02() 方法被调用
method_01() finally { }
abc

说明：
先计算好需要被return的值等待return，等到finally{ } 执行完后，在把已经计算好的值return。

finally在return之前执行
public class Test{

        pulic static void main(){
                System.out.println(new Test().test);
        }
        static int test(){
          int x = 1;
          try{
                return x;
          }finally{
                ++x;
          }
        }

}


结果为1;主函数调用test时，首先获得了结果，然后再将逻辑返回到主函数中，所以说先执行的fianlly；

有一个很好判断的方法，记住，finally是必须要执行的！！！不论是在try还是catch中，只要有结束该方法函数的语句，在执行该语句之前就会先执行finally中的语句，再返回继续执行结束语句。如果finally中有结束方法的语句，就会直接结束该方法的调用。