刚看了一个帖子，大家都在争论在return中使用finally，哪个先执行？看下下面两个小程序

1. class  Finally
   
2. {
   
3.         public static void main(String[] args)
   
4.         {        
   
5.                 System.out.println(myTest());
   
6.         }
   
7.         public static int myTest()
   
8.         {
   
9.                 int ret=0;
   
10.                 try
    
11.                 {
    
12.                         ret+=1;
    
13.                         return ret;
    
14.                 }
    
15.                 catch(Exception e)
    
16.                 {
    
17.                         ret+=10;
    
18.                 }
    
19.                 finally
    
20.                 {
    
21.                         ret+=100;
    
22.                         System.out.println("finally…………ret="+ret);
    
23.                 }
    
24.                 return 0;
    
25.         }
    
26. }
    
27. class Finally2
    
28. {
    
29.         public static void main(String[] args)
    
30.         {
    
31.                 for(int i=1;i<=4;i++)
    
32.                         fuc(i);
    
33.         }
    
34.         public static void fuc(int i)
    
35.         {
    
36.                 try
    
37.                 {
    
38.                         System.out.println("try 1……");
    
39.                         if(i==1)        return;
    
40.                         System.out.println("try 2……");
    
41.                         if(i==2)        return;
    
42.                         System.out.println("try 3……");
    
43.                         if(i==3)        return;
    
44.                         System.out.println("END");
    
45.                         return;
    
46.                 }
    
47.                 finally
    
48.                 {
    
49.                         System.out.println("finally…………");
    
50.                 }
    
51.         }
    
52. }

复制代码

输出结果如图：
到底那个先执行，还是没啥关系？

狼王 发表于 2013-6-10 18:43
finally先执行.
方法在顺序化的一直往下执行,发现了Rerurn(并未执行),它知道它快活不下去了,临死前.他就去 ...

嗯！:handshake我写的第二个例子很能说明问题……

finally先执行.
方法在顺序化的一直往下执行,发现了Rerurn(并未执行),它知道它快活不下去了,临死前.他就去找Finally,让Finally把事情做完.这种情况在Debug的时候比较明显,走到Return所在行,就进Finally,然后在回到Rerurn,做返回