1. package test;
   
2. 
   
3. public class Test {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 System.err.println(new Test().method1());
   
7.                 System.err.println(new Test().method2());
   
8.         }
   
9.         
   
10.         public int method1() {
    
11.                 int x = 1;
    
12.                 try {
    
13.           return x;//为什么执行完finally块后，还会回到这里返回？而method2不会?
    
14.          } finally {
    
15.                         ++x;
    
16.          }
    
17.         }
    
18.         
    
19.         public int method2() {
    
20.                 int x = 1;
    
21.                 try {
    
22.                         return x;//这里最后又没有返回？
    
23.                 } finally {
    
24.                         return ++x;//还是这里返回？为什么？
    
25.          }
    
26.         }
    
27. }
    

复制代码

控制台输出是：1  2
疑问在代码注解里面，求详解！（推荐使用debug run，查看详细执行步骤）

这是因为try catch finally中的finally不管在什么情况之下都会执行，执行的时间是在程序return 之前.
finally语句中语句必须被执行，首先在method1中在return前先执行finally语句。
在method2中在执行finally时因为finally中有return所以执行finally中return ++x再执行try中方法返回语句。
你执行下面一段代码就知道了。

1. package zhangxiao;
   
2. 
   
3. 
   
4. 
   
5. public class Test {
   
6. 
   
7. public static void main(String[] args){
   
8. System.err.println(new Test().method1());
   
9. System.err.println(new Test().method2());
   
10. }
    
11. 
    
12. public int method1() {
    
13. int x = 1;
    
14. try {
    
15. return x;//为什么执行完finally块后，还会回到这里返回？而method2不会?
    
16. } finally {
    
17. ++x;
    
18. }
    
19. }
    
20. 
    
21. @SuppressWarnings("finally")
    
22. public int method2() {
    
23. int x = 1;
    
24. try {
    
25. System.out.println("afa");
    
26. return x;//这里最后又没有返回？
    
27. } finally {
    
28. System.out.println("aa");
    
29. return ++x;//还是这里返回？为什么？
    
30. }
    
31. }
    
32. }

复制代码

还是简单点吧：
finally  在正常情况下是必须执行的，
关键是搞懂 它在什么时候执行！
在这个函数里面，它是在线程结束前 执行的，第一个没有返回  所以 输出 接收到的就是 try 返回的
第二个返回了， 因为在try执行完才执行的finall  所以输出 就收到的就是finally 返回的 2

吴小铁你好 发表于 2012-6-11 14:24
这是因为try catch finally中的finally不管在什么情况之下都会执行，执行的时间是在程序return 之前.
final ...

你的意思是,method1里边是先执行finally块再到try？
而method1正确的执行顺序是 13行-->15行-->13行;
method2: 22行-->24行
我的问题是：为什么method1里面，还会返回到13行

这里是一个try、finally语句执行顺序的例子，你看一下，我感觉你就明白了。
public class JVMTest {
public static void main(String[] args){
System.out.println("aa:" + aa());
}
public static int aa(){
int a = 1;
int b = 10;
try{
System.out.println("abc");
return a;
}finally{
a = 2;
System.out.println("a: "+ a);
}
}
}

运行结果为：

abc
a: 2
aa:1

由此可知：在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。
在转去之前，try中先把要返回的结果存放到不同于a的局部变量中去，执行完finally之后，在从中取出返回结果，
因此，即使finally中对变量a进行了改变，但是不会影响返回结果

孙新强 发表于 2012-6-11 14:44
这里是一个try、finally语句执行顺序的例子，你看一下，我感觉你就明白了。
public class JVMTest {
public ...

那如果finally块里面也有return语句，就会把之前用来存放返回结果a变量值给覆盖掉？

在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了，然而finally中的return语句结束了对method2的调用，所以method2中没有返回到try语句块中执行。