try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

[shoutor]

try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

[myhexiong]

楼楼楼上的，b当然返回5了。因为finally在return之前。

[zhangsn]

学习！！！！！！！！！

[cc555]

你写一个很简单的例子就知道了
string str = "aa";
try
{
str = "bb";
return;
}
catch
{
str = "cc";
}
finally
{
str = "dd";
}
你看一下最后的结果是"bb"还是"dd"

为什么叫finally就是因为它始终是要执行的
不执行叫什么finally呢?
所以你即使return了这个值还是会按照finally里面的来执行




------------------

finally是会执行，
但结果仍是bb

如下测试：

private string Do(){

string str = "aa";
try
{
str = "bb";
return str;
}
catch
{
str = "cc";
}
finally
{
str = "dd";
}

}




调试Do()，返回结果为bb

[shaohaiou]

finally里的代码是在return之前执行，而且是一定要执行的代码，所以一般数据库连接关闭语句都放这里，即使出错了还是要把连接给关了先

[shuaizq77]

执行！且在return之前！不过要注意finally块中的运算不会改变try块中result的值。

以下代码的执行结果为：
13 : from finally block
3

public class ExceptionTest {

public int add() throws Exception{
int a = 1, b = 2;
int result = 0;

try {
result = a + b;
//throw new Exception();
return result;
} catch (Exception e) {
// TODO: handle exception
} finally {
result = result + 10;
System.out.println(result + " : from finally block");
}
return result;

}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
ExceptionTest et = new ExceptionTest();
System.out.println(et.add());
}

}

[weider]

[Quote=引用 30 楼 ltmltm123456 的回复:]
这个结果可以证明是执行完finally里面的代码后才return的
[/Quote]

结果是bb，证明finally是在return后才执行的

[m_angle_m]

fianlly里的一定会执行的，不过大多都说是在return之前执行，这个是之前还是之后还真不清楚，好像还没有权威的说法。

[m_angle_m]

不过在我的印象中应该是之后执行

[m_angle_m]

想起来了，如果finally中没有return那么finally中的code就在return之前执行
如果finally中有return，一般的编译器会提示警告，try中的return将不会执行。

[yinxvxv]

public class TryCatch {
public String str= "05";
public static void main(String[] args) {
TryCatch tryCatch = new TryCatch();
System.out.println(tryCatch.setStr());
System.out.println(tryCatch.str);
}

public String setStr(){
try {
str = "10";
return str;
}catch (Exception e) {
str = "15";
}finally{
str = "20";
}
return "25";
}
}

运行结果为：
10
20
说明是在之后执行，因为return的数据还是10.
如果在finally中有return会有警告，并只执行finally中的return.

[congdepeng]

package depeng.test;

/**
* Created by IntelliJ IDEA.
* User: depeng
* Date: 2010-6-3
* Time: 15:06:03
* To change this template use File | Settings | File Templates.
*/
public class Finally {
public static void main(String[] args) {

System.out.println(sss());
}


static String sss(){
String str = "aa ";
try {
str = "try ";
return str ;

}
catch(Exception e)
{
str = "catch ";
System.exit(-1);
}
finally
{
str = "finally ";
}
return str ;
}
}

[naucca]

测试：
public class Test {
public static void main(String[] args) {
System.out.println(new Test().test());
}

int test() {
try {
return func1();
} finally {
return func2();
}
}

int func1() {
System.out.println("func1");
return 1;
}

int func2() {
System.out.println("func2");
return 2;
}
}

-----------执行结果-----------------
func1
func2
2

结论：finally中的代码在return代码之后执行

[celeron729]

return->finally
就这么简单！

[秀川001]

[Quote=引用 33 楼 witer666 的回复:]

楼上各位将士,不用争战了,我亲自试了一下,finally中的代码是执行的.楼主结帖,楼主害人不浅啊,让这么多将士在此自相惨杀,看了心寒啊!
[/Quote]
你应该表达错了，不是最后执行，应该是在return之前执行的，finally的意思应该不是说执行顺序，而是说这个代码出现或者不出现错误，finally这句最终肯定要执行的意思

[maquena]

finally是一定会执行的，就看是什么时候执行，设计如下测试代码：
public class TestFinally {
private static int x = 1;
public static void main(String[] args) {
System.out.println(test());
//1，证明finally并非在return之前执行
System.out.println(test());
//2，证明finally是执行了的，那么是怎么执行的呢？
System.out.println(get());
//2，先执行return，执行之后并没有立刻返回，而是将值放进栈中，执行finally之后再将结果返回
}
private static int get() {
try{
System.out.println("try...");
return 1;
}finally{
System.out.println("finally...");
return 2;
}
}
public static int test(){
try{
return x;
}finally{
x = 2;
}
}
}
使用Eclipse中的debug，也可以看到先return，再finally，再return，所以说finally是在return时执行的。

[hebut_wf]

在return前执行

在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。
在转去之前，try中先把要返回的结果存放到不同于a的局部变量中去，执行完finally之后，在从中取出返回结果，
因此，即使finally中对变量a进行了改变，但是不会影响返回结果。
它应该使用栈保存返回值。

[liqiaomu410]

说不执行的人 确实不咋的啊 楼上的意见支持

[wwq1586]

傻B得人还真多，测试finally时弄什么变量赋值啊，不会整个print字符，看看有没有东西打出来就知道执行没执行。

[asafsafsadf]

finally一定会执行的，唯一之中情况下就是在finally中不会执行就是
try{System.exit(1)}finally{...}在代码中退出了java虚拟机那么finally不会被执行
如果try或catch中有return那么finally是在return中间执行的，
try{
int x=1;
System.out.println("ok1");
return x;
}finally{
Sysem.out.println("ok2");
x++;
}
打印
ok1
ok2
1
当try或catch中有return的的时候先执行return让后将返回结果保存在函数栈，并不是马上返回它要执行了finally中的语句后才真正的开始返回

[JimmyLincole]

finally的语句是一定执行的..因为我试过..当然,我们知道..如果是在return后面执行的话,那就矛盾了,所以是在return之前就执行的了