A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 薄炳鑫 黑马帝   /  2012-6-30 11:44  /  2584 人查看  /  11 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 薄炳鑫 于 2012-6-30 12:50 编辑

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

11 个回复

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

但是如果不是return,而是System.exit(0); 则直接结束程序 不再执行下面的finally内语句
回复 使用道具 举报
finally在没有System.exit(0) 虚拟机退出语句就一定会被执行,   应该是先执行finally语句在执行return。
回复 使用道具 举报
郑庆伟 发表于 2012-6-30 11:57
finally在没有System.exit(0) 虚拟机退出语句就一定会被执行,   应该是先执行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 + 2;
                } finally {
                        i = 10;
                }
        }
}
先return后finally的结果是2
先finally后return的结果是12
楼主自己验证吧- -
回复 使用道具 举报
try{
return 语句
}
catch(Excepiton e){
throw new RunTimeException();
}
finally{
执行语句;
}
try里的return语句如果抛出异常了,就不会被执行,就直接到catch里处理完后,再执行finally里的语句
try里的return语句正常执行了,就是没抛出异常,就会接着执行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的执行过程
代码是我随手打的可能有点小问题,我没有调试,希望你能谅解!

评分

参与人数 1技术分 +1 收起 理由
刘蕴学 + 1

查看全部评分

回复 使用道具 举报
本帖最后由 郑庆伟 于 2012-6-30 12:55 编辑

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。

评分

参与人数 1技术分 +1 收起 理由
刘蕴学 + 1 思路对,方法错了

查看全部评分

回复 使用道具 举报
郑庆伟 发表于 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.                 int i = new ACC().Test();
  5.                 System.out.println(i);
  6.                 


  7.             }
  8.             public int Test(){
  9.                     int i = 0;
  10.                 try {
  11.                     System.out.println("Try 里的return");
  12.                     return i+=1;

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

  16.                 }
  17.                 finally {
  18.                     System.out.println("Finally 里的return");
  19.                     return i+=2;

  20.                 }
  21.             }
  22. }
复制代码
回复 使用道具 举报
会执行  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。

评分

参与人数 1技术分 +1 收起 理由
刘蕴学 + 1

查看全部评分

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



评分

参与人数 1技术分 +1 收起 理由
刘蕴学 + 1

查看全部评分

回复 使用道具 举报
先抛出经过测试验证的结论,等会大家可复制代码测试下:
结论:
        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.         public static Person TestTry1() throws Exception{
  7.                 int i = 1;
  8.         /*
  9.                 try{
  10.                
  11.                         return ++i; // xxx 语句 (1)
  12.                 }catch(Exception e){
  13.                        
  14.                         System.out.println("1--------------");
  15.                         return 0 ;
  16.                 }finally{
  17.                         ++i;
  18.                         System.out.println("finally1 execute-------- i="+i); // 流程执行try 中语句后 会先回到finally中先执行此中语句
  19.                         // 但有个特性时,finally里的 i 重新赋值不影响try 里的return ,因这里的块语句,在(1)语句后,此中块被内存释放了
  20.                         // 所以 会先重新申请一内存地址 存放i=2的值 , 程序再在finally中改变i的值 ,已经没有影响了,两者独立了。               
  21.                 }
  22.         */
  23.                 try{
  24.                         //throw new Exception();
  25.                          //System.exit(0);
  26.                     return new Person(++i,"try1"); //(1)
  27.                        
  28.                 }catch(Exception e){
  29.                         System.out.println(" catch run --------, this can not possible"); // (2)
  30.                         //throw e ;
  31.                         return new Person(i,"catch1"); // (3)
  32.                 }finally{
  33.                         ++i;
  34.                    new Person(i,"finally1"); // (4)
  35.                
  36.                 }
  37.                 /*
  38.                         流程是先执行 (1),执行(1)之后,不会立马return 回去,而是去执行了(4)呢,
  39.                         执行(4) 后了之后, 才会直接 return 个 try 中 Person 回去。
  40.                        
  41.                         若 (4) 前面 加了 return时,此时会返回 finally中的Person 回去,不会返回try 中的Person 回去。

  42.                         结论:
  43.                             1. finally 里 始终会被执行到, System.exit(0); 除这种被执行外。即使是发现了异常,如(3)中被注释的throw 异常,也会在抛异常前先执行finally.
  44.                                 2. 即使try中有return ,也是先执行 return 后面的语句完了之后, 不立马return,而是去执行finally中的语句。
  45.                                 3. 当try中与finally里,同时出现return , 则只会返回 finally 中的return 结果。
  46.                                 4. finally中的值不能影响try中 即将返回的结果值。
  47.                         以上对try中与finally中的结论,同样适用于catch 与 finally里,
  48.                             1. finally 里 始终会被执行到, System.exit(0); 除这种被执行外。即使是发现了异常,如(3)中被注释的throw 异常,也会在抛异常前先执行finally.
  49.                                 2. 即使catch中有return ,也是先执行 return 后面的语句完了之后, 不立马return,而是去执行finally中的语句。
  50.                                 3. 当catch中与finally里,同时出现return, 则只会返回 finally 中的return 结果。
  51.                                 4. finally中的值不能影响catch中 即将返回的结果值。

  52.                         注意: 若finally中没有return 在 try或catch中有return , 那么在执行return 跟着语句之后,会把语句的结果新开辟一内存空间,直接把结果的存放此内存空间中。
  53.                        
  54.                 */

  55.     }

  56.        

  57. }


  58. class Person
  59. {
  60.         private int num = 0;
  61.         private String location ;
  62.         public Person(int num,String location){
  63.                 this.num = num;
  64.                 this.location = location;
  65.                 System.out.println("------ "+location+" Person can execute---------- num="+num);
  66.        
  67.         }

  68.         public String toString(){
  69.        
  70.                 return "{Person num=["+num+"]+ location=["+location+"]" ;
  71.         }

  72. }
复制代码

评分

参与人数 1技术分 +3 收起 理由
刘蕴学 + 3

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马