import java.util.*;
class FanXing
{      
        public static void main(String[] args)
    {
           
                        int n=method(1);
                        if(n==1)
                                System.out.println("finally在return后执行");
                        if(n==2)
                                System.out.println("finally在return前执行");
                       
                       
                          
        }
        public static int method(int x)
        {
               
            try
        {
                        System.out.println("try----a------(x)="+x);
                        return x;
        }
        finally
                {
                        System.out.println("finally----b-----(x)="+x);
                        ++x;
                        System.out.println("finally----c-----(x)="+x);
                }
        }
      
}

运行结果
---------- java ----------
try----a------(x)=1
finally----b-----(x)=1
finally----c-----(x)=2
finally在return后执行

输出完毕 (耗时 0 秒) - 正常终止

   try
         {
                         System.out.println("try----a------(x)="+x);
                         return x;
         }
         finally
                 {
                         System.out.println("finally----b-----(x)="+x);
                         ++x;
                         System.out.println("finally----c-----(x)="+x);
                 }
         }
这是Java语法的规定，finally是必执行的语句
JVM通过一定的机制，用栈保留现场，最后执行！
这些，交给机器来写的，呵呵

没看明白楼主要表达什么？
如果finally 是在return后执行，那么程序在return的时候就已经跳出了 public static int method(int x)并返回x=1的结果。
可你这程序都已经打出了
finally----b-----(x)=1
finally----c-----(x)=2
finally的输出结果，也证明了方法传递结果前已经运行了finally。还是证明了finally是在传递参数也就是执行return跳出程序前运行的。

只有一个让finally不执行的方法,那就是System.exit();

何万县 发表于 2012-3-31 19:20
try
         {
                         System.out.println("try----a------(x)="+x);

支持你的推论，其实try catch finally的执行过程 十分复杂，楼主的例子本身不够严谨。不能支持楼主的结论。
其实 finally 语句块是在 try 或者 catch 中的 return 语句之前执行的。更加一般的说法是，finally 语句块应该是在控制转移语句之前执行，控制转移语句除了 return 外，还有 break 和 continue。另外，throw 语句也属于控制转移语句。

1.                                
   
2. public class Test {
   
3. public static void main(String[] args) {  
   
4. System.out.println("reture value of test() : " + test());
   
5.          }
   
6.        
   
7. public static int test(){
   
8. int i = 1;
   
9.                
   
10. try {  
    
11. System.out.println("try block");  
    
12.                          i = 1 / 0;
    
13. return 1;  
    
14. }catch (Exception e){
    
15. System.out.println("exception block");
    
16. return 2;
    
17. }finally {  
    
18. System.out.println("finally block");  
    
19.                  }
    
20.          }
    
21. }
    

复制代码

结果：

1. try block
   
2. exception block
   
3. finally block
   
4. reture value of test() : 2

复制代码

还有楼上说法也不对
这个另说

龚龙 发表于 2012-3-31 19:37
只有一个让finally不执行的方法,那就是System.exit();

                               
public class Test {
public static void main(String[] args) {
System.out.println("return value of test(): " + test());
         }

public static int test() {
int i = 1;
               
//                  if(i == 1)
//                          return 0;
System.out.println("the previous statement of try block");
i = i / 0;
               
try {
    System.out.println("try block");
      return i;
     }finally {
     System.out.println("finally block");
                 }
         }
}


的执行结果如下：

the previous statement of try block
Exception in thread "main" java.lang.ArithmeticException: / by zero
at com.bj.charlie.Test.test(Test.java:15)
at com.bj.charlie.Test.main(Test.java:6)


另外，如果去掉上例中被注释的两条语句前的注释符，执行结果则是：

return value of test(): 0


在以上两种情况下，finally 语句块都没有执行，说明什么问题呢？只有与 finally 相对应的 try 语句块得到执行的情况下，finally 语句块才会执行。以上两种情况，都是在 try 语句块之前返回（return）或者抛出异常，所以 try 对应的 finally 语句块没有执行。

finally语句是必须肯定要执行的，除非在finally执行之前jvm的进程退出了。
毋庸置疑的是：finally在执行完后才会return。
楼主的代码并不能说明先return再finally（++x;）的。
当代码中存在finally语句的时候执行到return语句会被线程暂时挂起，当执行完finally后再回到return语句执行返回。所以楼主的 代码用来理解return和finally的先后顺序比较牵强而且容易产生误导。
关键要理解中间return语句会被暂时挂起这一个很重要的细节。
这点完全可以通过eclipse调试工具来查看，你会发现语句执行到return后，跳到了finally块中，执行完后再回到return语句。
还有不懂的朋友们可以用工具来检验一下帮助理解！