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;
    
17.                 }
    
18.                 finally
    
19.                 {
    
20.                         ++x;
    
21.                 }
    
22.         }
    
23.        
    
24. }

复制代码

这里的返回结果为什么是1呢？求解。谢谢。

看错了。。finally 没有return

打印的是try代码块返回的1，
finnally里面只是对变量进行运算，却没有返回值
所以打印结果为1。

return 为返回语句，返回的时候x值为1, finally语句虽然最终要执行，但在finally执行的时候1作为x的值已经返回给调用者了，然后局部变量x再自增，对返回值没有影响。

对程序修改了一下可以得到你想要的结果了:

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(Test.test());
   
9.     }
   
10.    
    
11.     static int test()
    
12.     {
    
13.              int x=1 ;
    
14.             try
    
15.             {
    
16.                     return x;
    
17.             }
    
18.             finally
    
19.             {
    
20.                    return ++x;        //改为这句就自增了
    
21.                    // System.out.println("----"+x+"----");   
    
22.             }
    
23.     }
    
24.    
    
25. }

复制代码

try中return了x,finally中只是对x就行了自增运算，打印结果x的值为try中return时x的值，所以是1

关于这个问题也曾让我纠结过好久，这个属于边缘性问题，有很多种说法，不太适合过于钻牛角尖。
你可以利用反编译软件，跟踪虚拟机的具体执行过程，我下面理论上帮你描述一下。

根据java规范：在try-catch-finally中，如果try-finally或者catch-finally中都有return，则两个return语句都执行并且最终
返回到调用者那里的是finally中return的值；而如果finally中没有return，则理所当然的返回的是try或者catch中return的值，但是 finally中的代码是必须要执行的。

主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
下面是我写的代码，你做参考

1. public class FinallyTest  
   
2. {
   
3.         public static void main(String[] args) {
   
4.                  
   
5.                 System.out.println(test());
   
6.         }
   
7. 
   
8.         static int test()
   
9.         {
   
10.                 int x = 1;
    
11.                 try
    
12.                 {
    
13.                         return x=x+3;//执行return语句，返回结果已经准备好，并且被临时存储
    
14.                 }
    
15.                 finally
    
16.                 {
    
17.                         x=x+2;//finally中对变量x进行了改变，但是不会影响到return返回结果。
    
18.                         System.out.println(x);  
    
19.                         System.out.println("finally执行"); //执行完finally之后，取出临时存储的值返回
    
20.                 }
    
21.         }
    
22. }

复制代码