public  class Test {

        /**
         * @param args add by zxx ,Dec 9, 2008
         */
        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

try中的return语句调用的函数先与finally中调用的函数，也就是说return语句先执行finally语句后执行，所以返回的结果是1。
return并不是让函数马上返回，而是return语句执行后，将把返回结果放置静函数栈中，此时函数并不是马上返回，它要执行
finally语句后才真正开始返回。
可以从以下程序看出来

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

复制代码

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

func2

2

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

同学,那肯定是1了,

1. static int test()
   
2.         {
   
3.                 int x = 1;
   
4.                 try                                          {
   
5.                         return x;                          //先return,才会执行finally
   
6.                 }
   
7.                 finally
   
8.                 {
   
9.                         ++x;
   
10.                         System.out.println(x);               //这里才是2
    
11.                 }
    

复制代码

不执行finally的语句只有一条，那就是java.exit(0);其他的全部要执行的。

二楼的哥们，return在try...catch...finally语句中是跳不出来的，依旧会执行finally里面的语句的。

3楼正解                        

一、如果try catch finally块均无return则执行最后finally外的return；
如果try catch finally中任何一个有return则最后finally外的return不再执行；

二、只要finally块中有return则try或catch中的return不再执行.
总结：任何调用try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。

1. public  class Test {
   
2. 
   
3.         /**
   
4.          * @param args add by zxx ,Dec 9, 2008
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 System.out.println(new Test().test());;
   
9.         }
   
10. 
    
11.         static int test()
    
12.         {
    
13.                 int x = 1;
    
14.                 try
    
15.                 {
    
16.                         return x;//这里才是return回去的值.所以是1
    
17.                 }
    
18.                 finally
    
19.                 {
    
20.                         ++x;//这里是一定执行的x=2了..但是没return
    
21.                 }
    
22.         }
    
23.         
    
24. }
    
25. 为什么结果是1
    
26. 
    

复制代码

虽然，finally内的代码会在return之前执行，但是finally内的代码不能修改return 返回的值

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                
   
5.                 //调用测试方法
   
6.                 int i = test();
   
7.                 //输出i的结果，证明在finally中是否被修改
   
8.                 System.out.println(i);
   
9.         }
   
10.        
    
11.         public static int test() {
    
12.                
    
13.                 //定义一个变量
    
14.                 int i = 123;
    
15.                
    
16.                 try {
    
17.                         //表示try内的代码被执行
    
18.                         System.out.println("--------try---------");
    
19.                
    
20.                         //返回i的值
    
21.                         return i;
    
22.                        
    
23.                 } finally {
    
24.                         //对i进行重新赋值
    
25.                         i = 222;
    
26.                        
    
27.                         //表示finally块中的代码被执行
    
28.                         System.out.println("---------finally--------");
    
29.                 }
    
30.                
    
31.         }
    
32.        
    
33. }

复制代码

结果：
--------try---------
---------finally--------
123