java的try,catch,finally语句。我想知道下面的return语句执行完后，finally语句还是否要执行？执行过程是怎么样的？
try{
return 语句
}
catch(Excepiton e){
throw new RunTimeException();
}
finally{
执行语句；
}

先抛出经过测试验证的结论，等会大家可复制代码测试下：
结论：
        1. finally 里 始终会被执行到， System.exit(0); 除这种被执行外。即使是发现了异常，如(3)中被注释的throw 异常，也会在抛异常前先执行finally.
        2. 即使try中有return ，也是先执行 return 后面的语句完了之后， 不立马return，而是去执行finally中的语句。
        3. 当try中与finally里，同时出现return , 则只会返回 finally 中的return 结果。
        4. finally中的值不能影响try中 即将返回的结果值。
        以上对try中与finally中的结论，同样适用于catch 与 finally里，
        1. finally 里 始终会被执行到， System.exit(0); 除这种被执行外。即使是发现了异常，如(3)中被注释的throw 异常，也会在抛异常前先执行finally.
        2. 即使catch中有return ，也是先执行 return 后面的语句完了之后， 不立马return，而是去执行finally中的语句。
        3. 当catch中与finally里，同时出现return， 则只会返回 finally 中的return 结果。
        4. finally中的值不能影响catch中 即将返回的结果值。

注意： 若finally中没有return 在 try或catch中有return ， 那么在执行return 跟着语句之后，会把语句的结果新开辟一内存空间，直接把结果的存放此内存空间中。所以，finally中的值 不能影响try或catch中即将return的结果

------------下面是测试代码--------------------

1. public class TestTry1
   
2. {
   
3.         public static void main(String[] args) throws Exception{
   
4.                 System.out.println("client execute1 ------"+TestTry1());
   
5.         }
   
6. 
   
7. 
   
8.         public static Person TestTry1() throws Exception{
   
9.                 int i = 1;
   
10.         /*
    
11.                 try{
    
12.                
    
13.                         return ++i; // xxx 语句 (1)
    
14.                 }catch(Exception e){
    
15.                        
    
16.                         System.out.println("1--------------");
    
17.                         return 0 ;
    
18.                 }finally{
    
19.                         ++i;
    
20.                         System.out.println("finally1 execute-------- i="+i); // 流程执行try 中语句后 会先回到finally中先执行此中语句
    
21.                         // 但有个特性时，finally里的 i 重新赋值不影响try 里的return ，因这里的块语句，在(1)语句后，此中块被内存释放了
    
22.                         // 所以 会先重新申请一内存地址 存放i=2的值 ， 程序再在finally中改变i的值 ，已经没有影响了，两者独立了。               
    
23.                 }
    
24.         */
    
25.                 try{
    
26.                         //throw new Exception();
    
27.                          //System.exit(0);
    
28.                     return new Person(++i,"try1"); //(1)
    
29.                        
    
30.                 }catch(Exception e){
    
31.                         System.out.println(" catch run --------, this can not possible"); // (2)
    
32.                         //throw e ;
    
33.                         return new Person(i,"catch1"); // (3)
    
34.                 }finally{
    
35.                         ++i;
    
36.                    new Person(i,"finally1"); // (4)
    
37.                
    
38.                 }
    
39.                 /*
    
40.                         流程是先执行 (1)，执行(1)之后，不会立马return 回去，而是去执行了(4)呢，
    
41.                         执行(4) 后了之后， 才会直接 return 个 try 中 Person 回去。
    
42.                        
    
43.                         若 (4) 前面 加了 return时，此时会返回 finally中的Person 回去，不会返回try 中的Person 回去。
    
44. 
    
45.                         结论：
    
46.                             1. finally 里 始终会被执行到， System.exit(0); 除这种被执行外。即使是发现了异常，如(3)中被注释的throw 异常，也会在抛异常前先执行finally.
    
47.                                 2. 即使try中有return ，也是先执行 return 后面的语句完了之后， 不立马return，而是去执行finally中的语句。
    
48.                                 3. 当try中与finally里，同时出现return , 则只会返回 finally 中的return 结果。
    
49.                                 4. finally中的值不能影响try中 即将返回的结果值。
    
50.                         以上对try中与finally中的结论，同样适用于catch 与 finally里，
    
51.                             1. finally 里 始终会被执行到， System.exit(0); 除这种被执行外。即使是发现了异常，如(3)中被注释的throw 异常，也会在抛异常前先执行finally.
    
52.                                 2. 即使catch中有return ，也是先执行 return 后面的语句完了之后， 不立马return，而是去执行finally中的语句。
    
53.                                 3. 当catch中与finally里，同时出现return， 则只会返回 finally 中的return 结果。
    
54.                                 4. finally中的值不能影响catch中 即将返回的结果值。
    
55. 
    
56.                         注意： 若finally中没有return 在 try或catch中有return ， 那么在执行return 跟着语句之后，会把语句的结果新开辟一内存空间，直接把结果的存放此内存空间中。
    
57.                        
    
58.                 */
    
59. 
    
60.     }
    
61. 
    
62.        
    
63. 
    
64. }
    
65. 
    
66. 
    
67. class Person
    
68. {
    
69.         private int num = 0;
    
70.         private String location ;
    
71.         public Person(int num,String location){
    
72.                 this.num = num;
    
73.                 this.location = location;
    
74.                 System.out.println("------ "+location+" Person can execute---------- num="+num);
    
75.        
    
76.         }
    
77. 
    
78.         public String toString(){
    
79.        
    
80.                 return "{Person num=["+num+"]+ location=["+location+"]" ;
    
81.         }
    
82. 
    
83. }
    

复制代码

try...catch...finally
try
{
       //有可能出现异常的代码
    //没有异常就直接执行语句.然后再执行finally里面的语句
     //有异常就抛给catch语句
}
catch
{
     //处理异常的代码,执行完语句后再执行finally里面的语句
}
finally
{
        //finally的特点:
     //它永远都会被执行.
       //有一个特殊情况:如果在代码中jvm退出系统,那么finally就不会被执行.
}

会执行  finally里面的语句是在return 前执行 。但是return 后面的语句会在finally里面的语句前面执行。也就是说当执行到  return XXX;的时候，不会执行return，而是只执行XXX。然后执行finally里面的语句，最后在执行return；
把楼上的代码改一改
public class reDemo {
         public static void main(String[] args) {
                 System.out.println(method());
         }
         public static int method() {
                 int i = 0;
                 try {
                         return  i = i + 2;
                 } finally {
                         i = 10;
                         System.out.println("bbbb");
                 }
         }
}

打印结果 bbbb
              2

debug 调试会发现  i = i + 2  会在finally 语句前面执行 ，但是这里不会return。

郑庆伟 发表于 2012-6-30 12:49
public class TestFR{
    public static void main(String args[] ) {

别用直接返回值，用变量+=来检验过成

1. public class ACC
   
2. {
   
3.          public static void main(String args[] ) {
   
4. 
   
5.                 int i = new ACC().Test();
   
6.                 System.out.println(i);
   
7.                 
   
8. 
   
9. 
   
10.             }
    
11.             public int Test(){
    
12.                     int i = 0;
    
13.                 try {
    
14.                     System.out.println("Try 里的return");
    
15.                     return i+=1;
    
16. 
    
17.                 }catch(Exception ex) {
    
18.                    
    
19.                     System.out.println("异常");
    
20. 
    
21.                 }
    
22.                 finally {
    
23.                     System.out.println("Finally 里的return");
    
24.                     return i+=2;
    
25. 
    
26.                 }
    
27.             }
    
28. }

复制代码

public class TestFR{
    public static void main(String args[] ) {

        TestFR aa = new TestFR();
        int i = aa.Test();
        System.out.println(i);
        


    }
    public int Test(){
        try {
            System.out.println("Try 里的return");
            return 1;

        }catch(Exception ex) {
            
            System.out.println("异常");

        }
        finally {
            System.out.println("Finally 里的return");
            return 2;

        }



    }



}
抱歉想了很久才写出来 这里是是证明finally先执行的例子，如果是return先执行那么打印的是1，  这个例子运行的结果是2.证明是先运行的finally。

try{
return 语句
}
catch(Excepiton e){
throw new RunTimeException();
}
finally{
执行语句；
}
java中finally配合try使用表示永远执行，常用于关闭资源等操作，在执行try'的时候finally肯定会执行，而且是在return前执行，相对你这个程序来说当try中的语句执行到return的时候，他会先执行finally中的语句然后再返回try执行return
我给你写了一段代码，你看看结果你就会明白了
public class Test{
   public static void main(String args[]){
   System.out.println(Test.fun());
   }
  public static String fun(){
   try{
      System.out.println("在return之前的输出语句");
      return "s";
   }catch(Exception e){
      
  }finally{
    System.out.println("finally  被执行了");
   }
  
}
}
这是一个小的测试程序，输出的结果是   :
在return之前的输出语句
finally被执行了
s
这点就可以充分的说明了finally的执行过程
代码是我随手打的可能有点小问题，我没有调试，希望你能谅解！

try{
return 语句
}
catch(Excepiton e){
throw new RunTimeException();
}
finally{
执行语句；
}
try里的return语句如果抛出异常了，就不会被执行，就直接到catch里处理完后，再执行finally里的语句
try里的return语句正常执行了，就是没抛出异常，就会接着执行finally里的语句

public class reDemo {
        public static void main(String[] args) {
                System.out.println(method());
        }
        public static int method() {
                int i = 0;
                try {
                        return i + 2;
                } finally {
                        i = 10;
                }
        }
}
先return后finally的结果是2
先finally后return的结果是12
楼主自己验证吧- -

郑庆伟 发表于 2012-6-30 11:57
finally在没有System.exit(0) 虚拟机退出语句就一定会被执行，   应该是先执行finally语句在执行return。 ...

你和楼上说的哪个正好相反，能验证一下吗？

finally在没有System.exit(0) 虚拟机退出语句就一定会被执行，   应该是先执行finally语句在执行return。

会执行的，finally的执行顺序在return之后。
你可以写个代码测试一下。

但是如果不是return，而是System.exit(0); 则直接结束程序 不再执行下面的finally内语句