try-catch-finally小问题

Question

看这两个程序的输出结果是什么？（先做下试试，再测试～）public class Test
{
public static void main(String[] args)
{
System.out.println(tryTest());
} private static int tryTest()
{
int i = 0;
try
{
i = 1;
return i; //1处
}
catch (Exception e)
{
i = 2;
return i;
}
finally
{
i = 3;
}
}
}和public class Test
{
public static void main(String[] args)
{
System.out.println(tryTest());
} private static int tryTest()
{
int i = 0;
try
{
i = 1;
return i+0; //2处
}
catch (Exception e)
{
i = 2;
return i;
}
finally
{
i = 3;
}
}
}

Answer 1

都return的是1吧。。楼主不要忽悠我。

Answer 2

没什么区别，看看这个：
public class Test
{
    public static void main(String[] args)
    {
        System.out.println(tryTest());
    }    private static int tryTest()
    {
        int i = 0;
        try
        {
            i = 1;
            return i+0000; //2处 不管多少个0
        }
        catch (Exception e)
        {
            i = 2;
            return i;
        }
        finally
        {
            i = 3;
        }
    }
}1+0 和 1+0000 没什么区别。

Answer 3

明显都是1,在return那就返回了.不会再执行finally块了.

Answer 4

finally是最后执行的
之前已经return了

Answer 5

return之后再执行finally的，不会有什么变化的。

Answer 6

仁兄运行了代码没
可以这样加个打印信息再看看执行不 finally
        {
            System.out.println("------1------");
            i = 3;
            System.out.println("------2------");
        }

Answer 7

finally 是肯定执行的
只是返回值仍是1
如果这样子,就不一样了
private static int tryTest() {
int i = 0;
try {
i = 1;
return i+0; // 1处
} catch (Exception e) {
i = 2;
return i;
} finally {
i = 3;
return i;
}
}
public static void main(String[] args) {
System.out.println(tryTest());
}

Answer 8

finally 是无论如何都会执行 但是到底事在return 前 还是 return  后 执行  这个 有疑惑
不过大家  把代码稍微改一下 即知道答案
 finally {
System.out.println("------1------");
i = 3;
System.out.println("------2------");
}或者 用eclipse 调试一下  也可以看到答案

Answer 9

我不赞同这种答案，结果是1，不错；可是，记得fianally的语句块是一定要执行的，只是它的执行不影响结果而已

Answer 10

public class test { public static void main(String[] args)
    {
        System.out.println(tryTest());
    }    private static int tryTest()
    {
        Integer i = 0;
        try
        {
            i = 1;
            return i; //1处
        }
        catch (Exception e)
        {
            i = 2;
            return i;
        }
        finally
        {
            i = 3;
            return i;
        }
    }}

Answer 11

那大家看看这两个输出结果有什么不同吗？public class Test
{ public static void main(String[] args)
{
System.out.print(Test.testFinally(0) + "\t");
} private static StringBuffer testFinally(int flg)
{
StringBuffer result = new StringBuffer(""); result.append("1");
try
{
result.append("2");
return result; //1处
}
catch (Exception e)
{
return result;
}
finally
{
result.append("4");
}
}
}和public class Test2
{
public static void main(String[] args)
{
System.out.print(Test2.testFinally() + "\t");
} private static String testFinally()
{
StringBuffer result = new StringBuffer("");
result.append("1");
try
{
result.append("2");
return result.toString(); //2处
}
catch (Exception e)
{
return result.toString();
}
finally
{
result.append("4");
}
}
}

Answer 12

呵呵，这个问题提得好。
我的观点是返回值都是1。
因为，不论什么情况，finally都会执行，而且是在return之前执行。
但是，在finally里面的赋值是无效的。i是值变量，在try里面写了return i; 这时虚拟机栈已经把 i 这时的值copy到栈顶，然后才再去处理finnaly，之后对 i进行任何改变不会影响这时候栈顶的这个返回值，只会影响 i 的值。所以尽管此时i的值变了，但那是 i 的事情，不是Return的事情
如果在finnaly里面也加了return的话，这时候虚拟机栈又会把 i的值copy到return的栈顶。那么你看到的输出就不一样了！！

Answer 13

而且，即便你这里使用的不是那些简单类型，在finally中试图重新赋值也是无效的。
这里又是符合了java严格意义上的单向值传递。例如使用list，finally中你依旧可以向其中添加数据，但是若你想
list= null；却是没有作用的。已经存入栈顶的元素是一个深拷贝。

Answer 14

finally里的赋值是无效的？
看这个代码：
public class Test
{
    public static void main(String[] args)
    {
         System.out.println(tryTest());
    }    private static int tryTest()
    {
        int i = 0;
        try
        {
            i = 1;
            throw new Exception();
            
            
        }
        catch (Exception e)
        {
            i = 2;
            return i;
        }
        finally
        {
            i = 3;
            System.out.println(i);
            return i;
        }
    }
}

Answer 15

finally不是赋值无效，只是你返回的不是这个值

Answer 16

请看完整。18楼和20楼，我的答复原本应该是在一起的。
而且你的finally里面加了return语句，重新更改了栈顶元素的值，就是重新进行了一次深拷贝。
我说的有问题吗？

Answer 17

不要吓人，finally里的代码怎么都会执行。
至于16楼的不一样，就好比传String参数和StringBuffer参数的道理一样，引用的值是不变，引用所指的对象已经变了。

Answer 18

看StringBuffer的源代码：public synchronized String toString() {
return new String(value, 0, count);
    }

Answer 19

大家可以debug下，结果一目了然。
public class Test {
public static void main(String[] args) {
int a = tryTest(); //第1步（此时a=1）   第7步
System.out.println(a);  //第8步
} private static int tryTest() {
int i = 0;      //第2步
try {
i = 1;   //第3步
return i; //第4步  （执行了finally的i=3;之后再转回执行这句所以这也是  第6步）
} catch (Exception e) {
i = 2;
return i;
} finally {
i = 3;  //第5步（此时i=3）
}
}
}只是大概写了下步骤，再结合18楼的说法，这个题差不多可以解决了。
引用下18楼的：
i是值变量，在try里面写了return i; 这时虚拟机栈已经把 i 这时的值copy到栈顶，然后才再去处理finnaly，之后对 i进行任何改变不会影响这时候栈顶的这个返回值，只会影响 i 的值。所以尽管此时i的值变了，但那是 i 的事情，不是Return的事情 
如果在finnaly里面也加了return的话，这时候虚拟机栈又会把 i的值copy到return的栈顶。那么你看到的输出就不一样了！！ 

Answer 20

16楼程序只是有点点不同，StringBuffer类不同于String类，StringBuffer类的每个对象都是可以扩充和修改的字符串变量。
而在try-catch语句中，无论是否有异常抛出或者使用的return语句，finally块语句都会被执行。

Answer 21

这位仁兄说的对。。  不错 如果在 finally那位置在加个  return   i  那就是3啦

Answer 22

Think in java 中讲得很清楚。

Answer 23

finally 是在 return 前执行了

Answer 24

1. try成功--》finally
2.try出错-->catch-->finally
LZ是想明白执行顺序吧？
那个finally执行了，不过在执行前已经return  i值了。
所以。。