题目一：try{}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，
* 什么时候被执行，在return前还是后?使用程序验证。
*
*                 答:会，在return语句执行的中间运行的finally语句
*                         在try语句中,在执行return语句的时候,要返回的结果其实已经准备好了,
*                         这时候try中返回的结果先储存到一个局部变量中,执行完finally后,从中取出返回结果.
*                 1:  return i; //20  这个时候 只是进行了返回的标记，同时，确定要返回的数据值，没有真正的执行返回语句
*                 2:  执行了 finally语句
*                 3：      再回到return i; 返回当时的i值，也就是20
* 程序运行结果:
*                         产生了异常
*                         执行finally语句
*                         结果是:20
*                         程序结束了
* */
public class Try_Test {
        public static void main(String[] args) {
                System.out.println("结果是:"+new Try_Test().method(20));
               
                //System.out.println(result);
                System.out.println("程序结束了");
        }

        private static int method(int i) {//i = 20
                // TODO Auto-generated method stub
                try {
                        System.out.println(i/0);
                       
                } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println("产生了异常");
                        return i;//20
                }
                finally {
                        System.out.println("执行finally语句");
                        i++;//21
                }
                return 0;
       
        }


       
}

竟然没有人看,是我太水了么~

我来了，哈哈，这样做就可以了：

1. package com.ceshi;
   
2. 
   
3. /**
   
4. * 第一题：try{}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?使用程序验证。
   
5. *
   
6. * try{}里有一个return语句，那么紧跟在这个try后的finally {}里的code会 被执行到，在return后被执行到，验证程序如下：
   
7. * @author Administrator
   
8. *
   
9. */
   
10. public class TryFinally {
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 System.out.println(show());
    
14.         }
    
15.        
    
16.         /*
    
17.          * 定义show（）函数,用i来标记返回的值，如果finally语句块先于return执行，那么主函数当中最后打印输出的值应该是1；否则，主函数当中打印输出的值应该是0
    
18.          */
    
19.         public static int show()
    
20.         {
    
21.                 int i = 0;//用i来进行标识
    
22.                 try{
    
23.                         System.out.println("try running+++"+i);
    
24.                         return i;
    
25.                 }
    
26.                 finally{
    
27.                         i++;
    
28.                         System.out.println("finally running+++"+i);
    
29.                 }
    
30.         }
    
31. 
    
32. }
    

复制代码

上面已解释清楚，不再废话了。

1. //分析：在方法中定义整型变量num赋值为1；根据Java虚拟机的缓存机制来解决之个问题
   
2. //      如果先执行return：那么结果是这样的：[(1+1+1)+ 1] +{[(1+1+1)+ 1]+1} = 9
   
3. //      如果先执行finally:那么结果是这样的: {(1+1)+ [(1+1)+1]} + {(1+1)+ [(1+1)+1]+1} =11  
   
4. //      如果输出的结果为3，则是先执行return
   
5. 
   
6. /**
   
7. * 由于以下代码执行的结果是9，所以先执行的是return
   
8. */
   
9. class Test {
   
10.         public int method() {
    
11.                 // 声明整型数据num
    
12.                 int num = 1;
    
13.                 try {
    
14.                         num = num++ + num++;
    
15.                         return num;
    
16.                 } finally {
    
17.                         num = ++num + ++num;
    
18.                         System.out.println("num=" + num);
    
19.                 }
    
20.         }
    
21. }
    
22. public class Test8 {
    
23.         public static void main(String[] args) {
    
24.                 // 声明Test对象，调用方法
    
25.                 Test test = new Test();
    
26.                 test.method();
    
27.         }
    
28. }
    

复制代码

我是这么实现的

学习了！

赞一个~~

赞一个~~~

wangaz 发表于 2015-5-25 17:53
我来了，哈哈，这样做就可以了：上面已解释清楚，不再废话了。

我的程序没问题吧?只是发帖格式的问题的话那我就放心了

人在旅途~东营 发表于 2015-5-25 16:25
竟然没有人看,是我太水了么~

会执行，

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 /**
   
4.                  * 会执行，在return前执行;
   
5.                  * 分析：finally是不管遇到任何事都必须执行的语句块，如果在try中直接return了，
   
6.                  * 那么finally就执行不了，
   
7.                  * 就违背了这条规则，所以是先执行finally中的code再return
   
8.                  */
   
9.                 testOne();
   
10.         }
    
11. 
    
12.         public static String testOne() {
    
13.                 try {
    
14.                         System.out.println("执行到try语句块中！");
    
15.                         return "";
    
16.                 } catch (Exception e) {
    
17.                         // TODO: handle exception
    
18.                 } finally {
    
19.                         System.out.println("finally中的code执行了！");
    
20.                 }
    
21.                 return "";
    
22.         }
    
23. }

复制代码