public class Demo{
        public static int getData()
        {      
               
                try {
                return i;
                } catch (Exception e) {
                return 2;
                }finally{
                       
                        return 3;
                }
          }
                public static void main(String[] args) {
                       
                    System.out.println( getData() );
                }
}

首先是return 1;最后又会是 return 3;
疑问：return 1 这语句已经执行了，返回1啊，这个返回的这个1到哪了呢
    被3覆盖了？但1不是先返回去了吗
    谢谢！

谢谢各位，我明白了

希望我写的能帮到你理解

1. public class Test {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                
   
8.                 // TODO Auto-generated method stub
   
9.                 System.out.println("返回值:"+new Test().tt());;                                
   
10.         }
    
11. 
    
12. 
    
13.         static int tt() {
    
14.                 int x = 1;
    
15.                 try {
    
16.                         return Return();
    
17.                 }
    
18.                 finally {
    
19.                         ++x;
    
20.                         System.out.println("finally块执行,x="+x);               
    
21.                         //如果try与finally中都有return语句,返回值以finally的为准,返回值为2
    
22.                         //return x;
    
23.                                 
    
24.                 }
    
25.         }
    
26.         static int Return(){
    
27.                 System.out.println("return执行");
    
28.                 return 1;
    
29.         }
    
30. }
    

复制代码

运行结果:
return执行
finally块执行,x=2
返回值:1

可以通过下面一个例子程序来解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
可以用下面的程序来帮助分析：
public  class Test {

     public static void main(String[] args) {

          System.out.println(new Test().test());;

     }



     int test()

     {

          try

          {

              return func1();

          }

          finally

          {

              return func2();

          }

     }

     

     int func1()

     {

          System.out.println("func1");

          return 1;

     }

     int func2()

     {

          System.out.println("func2");

          return 2;

     }   

}

-----------执行结果-----------------



func1

func2

2



结论：finally中的代码比return 和break语句后执行

楼主的这个问题提的好巧
这是一个返回值区域问题
也就是说执行到try代码快的时候就要结束函数了
此时返回值区域是1
但是由于次函数内有finally代码快
所以在返回之前就执行了finally代码快的内容
执行完后返回值区域的值被覆盖成3
所以返回值就是3了
但是这个得在多么特殊的情况下才能用到
一般建议不要这么写
希望对你能有所帮助。。。

答：
    运行结果是3，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
   同样的
   public static void main(String[] args) {
                // TODO Auto-generated method stub
                System.out.println(new Test().test());;
        }

        static int test()
        {
                int x = 1;
                try
                {
                        return x;
                }
                finally
                {
                        ++x;
                }
        }
       
}

---------执行结果 ---------
1

   

你的代码中return 1;你看看是不是写错了。这个返回值：finally中的值无论什么情况都会执行返回的。
在try catch 中要看有没有异常发生，没有执行try中的值，有则执行catch中的值；另外还要看看try中值和发生异常的执行顺序。

看看这道程序，就可以明白了
package what;
import java.lang.reflect.*;
public class Test1 {
         public static int getData()
     {      
            
             try {
                    System.out.println(2);
             return 1;
             } catch (Exception e) {
             return 4;
             }finally{
                     
                     System.out.println(3);
             }
       }
             public static void main(String[] args) {
                     
                 System.out.println( getData() );
             }


}
结果：
2
3
1
执行顺序的问题：
首先执行try中语句，但是在try中执行return之前，会执行finally中的语句。
像楼主的程序则会先执行try块中的语句，但是在执行try中的return之前，finally中的语句会执行，像楼主在finally中加返回的话，就会直接返回了。不会再执行try中的返回。
我之后改的那个finally中不加return则会返回try中执行try中的return。