黑马程序员技术交流社区

标题: java异常里面的一个问题。 [打印本页]
作者: 薄炳鑫    时间: 2012-6-30 11:44
标题: java异常里面的一个问题。
本帖最后由 薄炳鑫 于 2012-6-30 12:50 编辑

java的try,catch,finally语句。我想知道下面的return语句执行完后，finally语句还是否要执行？执行过程是怎么样的？
try{
return 语句
}
catch(Excepiton e){
throw new RunTimeException();
}
finally{
执行语句；
}
作者: 黑马刘洋    时间: 2012-6-30 11:47
会执行的，finally的执行顺序在return之后。
你可以写个代码测试一下。

但是如果不是return，而是System.exit(0); 则直接结束程序 不再执行下面的finally内语句
作者: 郑庆伟    时间: 2012-6-30 11:57
finally在没有System.exit(0) 虚拟机退出语句就一定会被执行，   应该是先执行finally语句在执行return。
作者: 薄炳鑫    时间: 2012-6-30 12:00
郑庆伟 发表于 2012-6-30 11:57
finally在没有System.exit(0) 虚拟机退出语句就一定会被执行，   应该是先执行finally语句在执行return。 ...

你和楼上说的哪个正好相反，能验证一下吗？
作者: 黑马刘洋    时间: 2012-6-30 12:12
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 12:22
try{
return 语句
}
catch(Excepiton e){
throw new RunTimeException();
}
finally{
执行语句；
}
try里的return语句如果抛出异常了，就不会被执行，就直接到catch里处理完后，再执行finally里的语句
try里的return语句正常执行了，就是没抛出异常，就会接着执行finally里的语句
作者: 游洪波    时间: 2012-6-30 12:29
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的执行过程
代码是我随手打的可能有点小问题，我没有调试，希望你能谅解！
作者: 郑庆伟    时间: 2012-6-30 12:49
本帖最后由 郑庆伟 于 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。
作者: 刘蕴学    时间: 2012-6-30 13:00
郑庆伟 发表于 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[] ) {

  5.                 int i = new ACC().Test();
  6.                 System.out.println(i);
  7.                 


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

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

  21.                 }
  22.                 finally {
  23.                     System.out.println("Finally 里的return");
  24.                     return i+=2;

  26.                 }
  27.             }
  28. }
复制代码
作者: 黄克帅    时间: 2012-6-30 13:16
会执行  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 15:50
try...catch...finally
try
{
       //有可能出现异常的代码
    //没有异常就直接执行语句.然后再执行finally里面的语句
     //有异常就抛给catch语句
}
catch
{
     //处理异常的代码,执行完语句后再执行finally里面的语句
}
finally
{
        //finally的特点:
     //它永远都会被执行.
       //有一个特殊情况:如果在代码中jvm退出系统,那么finally就不会被执行.
}



作者: 陈淑飞    时间: 2012-6-30 23:24
先抛出经过测试验证的结论，等会大家可复制代码测试下：
结论：
        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.         }


  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 回去。

  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中 即将返回的结果值。

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

  60.     }

  62.        

  64. }


  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.         }

  78.         public String toString(){
  79.        
  80.                 return "{Person num=["+num+"]+ location=["+location+"]" ;
  81.         }

  83. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2