try中有return，finally块会不会执行

Question

 try{
   ……
  return;
  }catch（Exception e）{  e.printStackTrce;  }finally{  ……
 }
上述程序块中，在try中没有发现异常的话，finally块中的语句是否会执行？

Answer 1

会执行！当没有发现异常的话finally里的语句会在return之前执行。

Answer 2

会，除非：
public class Test {  public static void main(String[] args) throws Exception {
    foo();
  }  static int foo() throws Exception {
    try {
      System.out.println("1");
      System.exit(1);
      System.out.println("2");
      return 2;
    } finally {
      System.out.println("3");
    }
  }
}

Answer 3

会执行，try中遇到return关键字时会先跳到finally块中执行，执行完了就回来执行return语句了你也可以自己设一个段点看看，映像会深些

Answer 4

不管有没有发现异常，finally语句块中的语句总会执行的
建议你写一个测试类体会体会

Answer 5

除强制退出外System.exit()都执行

Answer 6

finally里边的语句,会在return之前执行;
所以finally一般用来做一些清尾工作,如:释放连接,等等.
除非你在catch里关了JVM .

Answer 7

对，会执行，在return前执行。

Answer 8

呵呵，前几天的面试题。
程序会先执行finally中的代码然后执行return

Answer 9

楼主自己把这段小程序完善下，加个main方法，加几个控制台打印，此贴答案立即就有了。这个问题的答案当然是：finally会被执行，无论正常情况下还是出异常情况下，且在return前执行。

Answer 10

一定会执行，try。catch。。finally ，finally模块里的东西是一定会执行的。

Answer 11

一定会执行！ 有或没有异常都会执行当没有发现异常的话finally里的语句会在return之前执行。

Answer 12

如果try{}模块中的语句没有错误,catch{}模块里的就不会执行了,但finally{}模块里的语句无论有没有异常都执行,try{}里语句有问题return 就肯定不会执行了被

Answer 13

是这样的，不过发现在发现异常时候，异常句子的后面的语句不会执行的
例如
 try{
int a=10;
 int b=0;
 a=a/b;
System.out.println("能执行后面的语句吗？")
}
catch(Exception e)
{
....
}
finally
{
System.out.println("这一句是会执行的哦！");}
运行程序后，你会发现System.out.println("能执行后面的语句吗？")没有打印出来
System.out.println("这一句是会执行的哦！");这一句打印出来了

Answer 14

借3楼的代码：public class Test {  public static void main(String[] args) throws Exception {
    foo();
  }  static int foo() throws Exception {
    try {
      System.out.println("1");
      //你在这里加入一段异常代码，能帮你更好的理解
       System.out.println(5/0);//被零除
      System.exit(1);
      //System.exit(0);//不管是否是正常退出或异常退出
      System.out.println("2");
      return 2;
    } finally {
      System.out.println("3");
    }
  }
}
结果：
1
3
Exception in thread "main" java.lang.ArithmeticException: / by zero

Answer 15

debug一下比什么都清楚，或是多打印几个system.out就知道了
这个问题以前scjp考过

Answer 16

http://blog.csdn.net/ZangXT/archive/2009/05/21/4206672.aspx

Answer 17

当然执行了，如果Try 和finally里都有return的话
大家猜猜return的是哪一个？
:)

Answer 18

肯定会，必须会，否则就不是finally，finally==终结者！

Answer 19

finally块里面的代码是一定会执行的 ，在try代码块返回之后

Answer 20

finally是必须执行的..return执行后方法就跳出了.你看是哪个先执行,哪个后执行?

Answer 21

会执行！ 
发生异常与否,finally里的语句都会在return之前执行。

Answer 22

会执行！ 
发生异常与否,finally里的语句都会在return之前执行。呵呵 灌水哦

Answer 23

  我怎么感觉到，你一运行try就关机似得。
    那它永远不执行finally.O(∩_∩)O哈哈~

Answer 24

finally会执行，并且是在return 之前执行！
你可以写个小例子，设上断点试试看！

Answer 25

自己 多加几个 system.out.print()看看

Answer 26

除强制退出外System.exit()
都执行 
当没有发现异常的话finally里的语句会在return之前执行

Answer 27

建议写个debug跟踪调试下。祝君好运。

Answer 28

会执行  
  System.exit(0);就不会执行了。

Answer 29

会执行，try中遇到return关键字时会先跳到finally块中执行，执行完了就回来执行return语句了 
如果有Exception 同样会执行 finally 中的语句。

Answer 30

只要你中途try语句,catch语句内部没有 程序终止退出的语句：System.exit(0);那么就一定会执行，而且是在return之前执行，最好还是自己写一个来验证，加深印象！

Answer 31

说到这个我想起下面这段代码，丢失异常也是非常容易发生的class VeryImportantException extends Exception{
public String toString(){
return "A very important exception!";
}
}
class TrivialException extends Exception{
public String toString(){
return "A trivial exception!";
}
}
public class Test {
void f() throws VeryImportantException{
throw new VeryImportantException();
};
void dispose() throws TrivialException{
throw new TrivialException();
}
public static void main(String[] args) {
try {
Test t = new Test();
try {
t.f();
} finally {
t.dispose();
}
} catch (Exception e) {
System.out.println(e);
}
}
}重要的异常被无关紧要的异常给替换掉了

Answer 32

在try-catch-final块中的退出语句。注：  try-catch-final块的顺序不能调换    public class Test { 
        public static void main(String[] args) { 
         int a=1; 
         try { 
            a=a/0; 
           }catch(Exception e) { 
           System.out.println("catch");
           return;//当return时，finally中的语句会执行。 
                 //System.exit(0);
                 //若用上这句，finally中的语句不会执行。直接返回，退出程序。
           } finally 
             //当没有System.exit(0);时，无论是否发生异常它都会执行。{ 
           System.out.println("finally"); 
       }
    } 
  }

Answer 33

simply:
除了system.exit()外,都会执行.

Answer 34

zai在执行return前执行finally代码

Answer 35

finally中的return会覆盖原先try中的return

Answer 36

会，try()语句块中的finally无论如何都会执行。如果遇到return，则会在return前执行

Answer 37

JAVA异常处理有两种套路：1，捕获try-catch-finally。2，抛出throws
编程时应该先考虑用try-catch，而不是throws
捕获异常的格式:
try{ 
//可能发生异常的代码.... 
}catch(xxException e){ 
//异常发生以后处理的代码
}finally{
//不管发生不发生异常一定要执行的代码
}
finally可以出现1到N次，如果catch不出现就必须出现finally,catch出现了finally随便出现不出现
try只能出现一次，catch出现0-1次
它的运行顺序：
1，如果不发生异常时候执行try-finally
2，发生异常，try必定冲断，到catch
3，发生异常，try冲断到finally
4,发生异常，try冲断catch到finally继续运行下去，因为捕获了异常
try{
1
2
3
}catch(){
4
}
finally{
5
}
6
2若发生异常，则程序执行了1,2,4,5,6执行完毕
方法终结的3种，1，代码执行完了；2，执行到return ；3，有未捕获异常抛出

Answer 38

package com.myjava;public class TestReturn {   public static void main(String[] args) throws Exception {
    int a = foo();
    System.out.print(a);
  }   static int foo() throws Exception {
    try {
      System.out.println("1");
      //System.exit(1);
      System.out.println("2");
      return 2;
    } catch(Exception e){
     e.printStackTrace();
    }finally {
      System.out.println("3");
      return 8;
    }
  }}
理解一下这个

Answer 39

这个是System.exit(1);
还是System.exit(0);
这个什么区别啊！

Answer 40

public class Test { static int i = 0; /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = test();
System.out.println("a = " + a);
System.out.println("i = " + i);
} static int test() { try {
++i;
return i;

} catch (Exception e) { } finally {
System.out.println(i);
i=5;

}
return 100;
}
}

Answer 41

这是肯定的，肯定会执行，在try的return之前执行，然后再return！