看一下你对return和finally的执行顺序理解是否正确

Question

本帖最后由 hejinxu 于 2010-04-20 15:42:52 编辑

Answer 1

楼主的这种写法不代表finally子句没有被调用！请看下面的例子。
class Test {
    public static void main(String[] args) {
        System.out.println("main=" + Test.test());
    }    static int test() {
        int x = 1;
        try {
            return x;
        } finally {
            ++x;
            System.out.println("x=" + x);
        }
    }
}上述例子执行结果是：x=2
main=1
这个问题可以告诉我们两个问题：
1. finally子句总是被调用。从Java语法的角度看这一点是正确的。
2. 不要在try子句中调用 return 语句。从编程规范的角度看你应该牢记这一条。

Answer 2

补充一点：
在没有异常发生时，异常子句的调用顺序是先调用try子句再调用finally子句。
所以楼主的代码是先调用 return x; 再调用 ++x; 很自然，主函数得到的返回值就是 1。 

Answer 3

2. 不要在try子句中调用 return 语句。从编程规范的角度看你应该牢记这一条。
这一条以前到是没怎么在意

Answer 4

楼主，你已经return了，这个方法即时返回了，后面任何语句都不执行了。和finally执不执行，没有关系吧。

Answer 5

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

Answer 6

这个问题csdn里讨论過n次了，大家看看这个文章，我刚去搜索出来的http://blog.csdn.net/exsuns/archive/2010/01/20/5217669.aspx

Answer 7

    static int testFinal1() {   
        int i = 1;   
        try {   
            return i;   
        } finally {   
            System.out.println("in testFinal1():finally 肯定会被执行的！");   
            i = 48;   
        }   
    }   
  
    static String testFinal2() {   
        String str = "try";   
        try {   
            return str;   
        } finally {   
            System.out.println("in testFinal2():finally 肯定会被执行的！");   
            str = "finally";   
        }   
    }   
  
    static StringBuilder testFinal3() {   
        StringBuilder build = new StringBuilder("try ");   
        try {   
            return build;   
        } finally {   
            System.out.println("in testFinal3():finally 肯定会被执行的！");   
            build.append("finally");   
            build = new StringBuilder("你猜我是谁！");   
        }   
    }   
  
    static String testFinal4() {   
        try {   
            return "return in try";   
        } finally {
            System.out.println("in testFinal4():finally 肯定会被执行的！");   
            return "return in finally";   
        }   
    } 

Answer 8

你才学try/catch吧，自已写代码去试..

Answer 9

我在二楼的相关描述不十分准确，在此更正一下。
通过学习可以知道：
1. finally子句总是被调用；
2. return操作总是在最后执行；
3. 总是最后一个return语句在起作用；
4. return语句返回的是变量的值而不是对象的内容。关于第2点，用通俗的话讲，如果在try子句中存在return语句，JVM做了两件事：
1. 记住最后一个return语句所处代码位置上需要返回的变量值；
2. 将这个值放在函数调用过程的最后返回。 也就是说，下面的例子：
public static String test(){
    String str = "try";
    try {
        return str;
    }finally {
        str = "finally";
    }
}本质上可以用下面的代码表示：
public static String test(){
    String tmp;  // 声明一个“用于返回数据的变量”
    String str = "try";
    try {
        tmp = str; // 将需要返回的值赋值给该变量
    }finally {
        str = "finally";
    }
    return tmp; // 将“用于返回数据的变量”的值返回
}详细的论述可以参考http://blog.csdn.net/darxin/archive/2010/05/07/5567689.aspxZangXT提供的http://blog.csdn.net/ZangXT/archive/2009/05/21/4206672.aspx
ArayChou提供的http://blog.csdn.net/exsuns/archive/2010/01/20/5217669.aspx
这两篇文章的描述都很准确，对我的帮助很大。在此表示感谢。