用代码证明，在try中写了return，后面又写了finally，
是先执行return还是先执行fianlly？

lz请看，代码已测试。
在异常处理的语法中往往伴随着try-catch语句块的出现，但是就异常处理的语法结构上来说只有try块是必须的，也就是说，如果没有try块，则不能有后面的catch块和finally块，catch块和finally块是可选的，但是catch块和finally块要至少出现一个。当然也可以同时出现，可以有多个catch块，捕获父类异常的catch块必须位于捕获子类异常的后面。但是不能同时没有两者，多个catch块必须位于try块之后，finally块必须位于所有的catch块之后，因为finally通常用于资源的回收，异常处理中的finally块总会被执行。

说了这么多，还是回到前面的问题上来，接下来就是代码的证明：


public class TryTest {
        public static void main(String[] args){
                System.out.println(test());
        }
        //自定义一个test测试函数
        public static boolean test(){
                try{
                        //用来检测try块里面处于return前的语句是否有被执行
                        System.out.println("此时try语句块正在被执行");
                        return false;
                }
                finally{       
                        //用来检测finally语句块中的语句有没有被执行
                        System.out.println("此时finally语句块正在被执行");
                        return true;
                }               
        }
}
程序最后运行的结果是：

此时try语句块正在被执行
此时finally语句块正在被执行
true
通过程序的运行结果可以看出，try中的return语句并没有被执行。
如果我注释掉finally语句块中return语句，程序的运行结果又会是什么样的呢？


此时try语句块正在被执行
此时finally语句块正在被执行
false


通过这两个运行结果的不同，我们不难得出结论
当java程序在执行try块、catch块时如果遇到了return或者throw时，这两个语句都会导致该方法立即结束，但是系统在执行这两个语句时并不会结束该方法，而是去寻找该异常处理流中是否包含了finally语句块，如果没有finally块，则程序会立即执行return或者throw语句，方法终止。如果有finally语句块，系统会开始立即执行finally语句块，只有当finally语句块中的代码被执行完了之后，系统才会回来再次执行try块或者catch块中的return或throw语句，但是如果finally块中也有return或者throw这样能是方法结束的语句，则finally块就会立即结束该方法，系统将不会跳回去执行try块或者catch中的任何语句。



所以在注释掉finally块中的return语句后，程序再次跳到了try中的return语句，最后结果返回了false。

用代码证明，在try中写了return，后面又写了finally，
是先执行return还是先执行fianlly？ 用代码证明，在try中写了return，后面又写了finally，
是先执行return还是先执行fianlly？

public class ReturnFinally {
        static int i = 0;
       
        public int method() {
                try {
                        return i++;
                } finally {
                        System.out.println("finally :"+i);
                }
        }
        //如果先执行finally则输出为0；实际是先执行return，但是执行完return后还得执行finally
        public static void main(String[] args) {
                ReturnFinally rf = new ReturnFinally();
                rf.method();
        }
}

//我之前看了一个帖子是这样写的，你可以参考一下.
/*思路：
要想证明程序的运行流程，那么就可以使用myeclipse中加入断电，然后debug单步执行，那么怎么在代码中实现呢，也就说怎么使用代码来证明呢？
  return是在finally执行后才返回的,且finally无法改变返回值
*/  
public class Test5 {  
  
      
    public static void main(String[] args) throws Exception {  
        //第一种方法,首先想到了利用数字来解决问题。想了想还是不能判断到底是先执行return还是先执行fianlly，只能来知道finally不能修改返回的值。  
        System.out.println("第一种："+tryTest1());  
        //第二种方法和第三种方法进行比较。发现try中的return是在fianlly执行之后才返回的。而且fianlly无法改变返回值。  
        System.out.println("第二种:"+tryTest2());  
        System.out.println("第三种:"+tryTest3());  
    }  
    //第一种方法,首先想到了利用数字来解决问题。想了想还是不能判断到底是先执行return还是先执行fianlly，只能来知道finally不能修改返回的值。  
    public static int tryTest1(){  
        int x = 0;  
        try {   
            x = 1;  
            System.out.print("try中的x值为："+x+"----");  
            return x;  
        } catch (Exception e) {  
            // TODO: handle exception  
        }finally{  
            x = 2;  
            System.out.print("finally中x值为："+x+"----");  
        }  
        return 0;  
    }  
    //第二种方法，想了想就使用StringBuilder来试着解决一下问题。在finally里面加入return。  
    public static String tryTest2()  {  
        String x = "try*****";  
        StringBuilder sb = new StringBuilder();  
        try {  
            System.out.print("try1-----");  
            System.out.print("try2-----");  
            sb.append(x);  
            return sb.toString();  
        } finally {  
            sb.append("finally");  
            System.out.print("finally3");  
            //最后加入return  
            return sb.toString();  
        }  
    }  
    //第三种方法，finally里面没有家人return。  
    public static String tryTest3() {  
        String x = "try*****";  
        StringBuilder sb = new StringBuilder();  
        try {  
            System.out.print("try1-----");  
            System.out.print("try2-----");  
            sb.append(x);  
            return sb.toString();  
        } finally {  
            sb.append("finally");  
            System.out.print("finally3");  
            //最后加入return  
            //return sb.toString();  
        }  
    }  
  
}

public class ReturnFinally {
        static int i = 0;
       
        public int method() {
                try {
                        return i++;
                } finally {
                        System.out.println("finally :"+i);
                }
        }
        //如果先执行finally则输出为0；实际是先执行return，但是执行完return后还得执行finally
        public static void main(String[] args) {
                ReturnFinally rf = new ReturnFinally();
                rf.method();
        }
}//楼主，看看能行不。急需积分。。

清浅。。 发表于 2014-12-16 22:36
//我之前看了一个帖子是这样写的，你可以参考一下.
/*思路：
要想证明程序的运行流程，那么就可以使用mye ...

楼主看看吧~我这已经很全面，很经典了，还有注解，急需钱币

我想了会就过了一天，错过了发帖奖励了:'(

1. class Test
   
2. {
   
3.         //初始化s
   
4.         static String s = "first";
   
5.         public static String testException()
   
6.         {
   
7.                 try
   
8.                 {
   
9.                         throw new Exception();
   
10.                 }
    
11.                 catch(Exception e)
    
12.                 {
    
13.                         //step1
    
14.                         System.out.println("s = " + s);
    
15.                         //step3
    
16.                         return (s = "second");
    
17.                 }
    
18.                 finally
    
19.                 {
    
20.                         //step2
    
21.                         s = "finally";
    
22.                         System.out.println("s = " + s);
    
23.                 }
    
24.         }
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 //step4
    
28.                 System.out.println(testException());
    
29.                 //step5
    
30.                 System.out.println("s = " + s);
    
31.         }
    
32. }

复制代码

return语句先执行，完成赋值操作s = "second"，将值保存，
再去执行finally，所以出现main方法中，在方法调用结束后，finally中的赋值操作
覆盖了return语句的赋值操作

finally 结束try catch 代码块 ;return 返回函数 （结束函数 ）如果 程序执行到return后不会执行finally ，因为函数都返回了

代码前面的都已经写清楚了。
try   
{   return (表达式1) ； // return 语句是3；
}
finally
{
  表达式2；
}
结果：先执行 表达式1， 再执行 表达式2 ， 然后执行 表达式3（也就是return语句）。

希望能帮到你。

public class TryTest {
        public static void main(String[] args){
                System.out.println(test());
        }
        //自定义一个test测试函数
        public static boolean test(){
                try{
                        //用来检测try块里面处于return前的语句是否有被执行
                        System.out.println("此时try语句块正在被执行");
                        return false;
                }
                finally{       
                        //用来检测finally语句块中的语句有没有被执行
                        System.out.println("此时finally语句块正在被执行");
                        return true;
                }               
        }
}
程序最后运行的结果是：

此时try语句块正在被执行
此时finally语句块正在被执行
true通过程序的运行结果可以看出，try中的return语句并没有被执行。
如果我注释掉finally语句块中return语句，程序的运行结果又会是什么样的呢？


此时try语句块正在被执行
此时finally语句块正在被执行
false


通过这两个运行结果的不同，我们不难得出结论
当java程序在执行try块、catch块时如果遇到了return或者throw时，这两个语句都会导致该方法立即结束，但是系统在执行这两个语句时并不会结束该方法，而是去寻找该异常处理流中是否包含了finally语句块，如果没有finally块，则程序会立即执行return或者throw语句，方法终止。如果有finally语句块，系统会开始立即执行finally语句块，只有当finally语句块中的代码被执行完了之后，系统才会回来再次执行try块或者catch块中的return或throw语句，但是如果finally块中也有return或者throw这样能是方法结束的语句，则finally块就会立即结束该方法，系统将不会跳回去执行try块或者catch中的任何语句。




所以在注释掉finally块中的return语句后，程序再次跳到了try中的return语句，最后结果返回了false。

学习了，感觉前面一些兄弟的回答很到位的。

wangbiao 发表于 2014-12-16 22:35
public class ReturnFinally {
        static int i = 0;
       

编译不能通过吧

wangbiao 发表于 2014-12-16 22:35
public class ReturnFinally {
        static int i = 0;
       

看错了，sorry

一般回答一起执行，如果深究的话，先执行fianlly

看代码，有注释

1. public class Test5 {
   
2.        
   
3.         public static void main(String[] s){
   
4.                
   
5.                
   
6.                 System.out.println(t());//返回的结果为15所以return先执行了
   
7.                
   
8.         }
   
9.        
   
10.        
    
11.         public static int t(){
    
12.                 int a  = 5;//定义一个变量用于证明谁先执行
    
13.             try {
    
14.                    
    
15.                         return a+=10;
    
16.                        
    
17.                 } catch (Exception e) {
    
18.                         e.printStackTrace();
    
19.                        
    
20.                 }
    
21.                 finally{
    
22.                         //如果a的值变了就说明了return先执行了
    
23.                         if(a>5){
    
24.                                 System.out.println("a>5了所以return先执行");
    
25.                         }else{
    
26.                                 System.out.println("a<5了所以finally先执行");
    
27.                         }
    
28.                         return a;
    
29.                 }
    
30.                
    
31.         }
    
32.        
    
33.        
    
34.        
    
35.        
    
36. }

复制代码

那麽多人回答了，为什么没有给被人黑马币

wangbiao 发表于 2014-12-16 22:35
public class ReturnFinally {
        static int i = 0;
       

有try了,是不是不能少catch啊

alston 发表于 2014-12-24 07:55
有try了,是不是不能少catch啊

可以不用catch，tyr-catch-finally有三种组合，分别是try-catch，try-finally，和try-catch-finally。
try以后不是必须使用catch的。需要捕获异常并处理的就用catch，不需要的话就不用；但是一般都建议捕获异常并且处理掉。

wangbiao 发表于 2014-12-24 10:17
可以不用catch，tyr-catch-finally有三种组合，分别是try-catch，try-finally，和try-catch-finally。
tr ...

很详细，，谢谢：）