1. /**
   
2. * 6、 写一个类证明return是在finally执行后才返回的，
   
3. * 且在finally无法改变返回值。
   
4. * finally用于异常时执行必须执行的操作
   
5. * 常用来关闭资源或者连接
   
6. *
   
7. */
   
8. class Max
   
9. {
   
10.         int m;
    
11.         public int da(int[] arr,int x)//数组中角标值
    
12.         {
    
13.                 try
    
14.                 {
    
15.                         if(x>arr.length||x<0)
    
16.                                 throw new RuntimeException("角标不存在");//抛出异常
    
17.                         for(int y=0;y<arr.length;y++)
    
18.                         {        
    
19.                                 if(x==y)
    
20.                                         m=arr[y];
    
21.                         }
    
22.                         return m;
    
23.                 }
    
24.                 catch(Exception e)
    
25.                 {
    
26.                         System.out.println(e.toString());
    
27.                 }
    
28.                
    
29.                 finally
    
30.                 {
    
31.                         System.out.println("finally执行");
    
32.                         m=0;        
    
33.                 }
    
34.                 return m;
    
35.                 //这要是注释了就0了
    
36.                 //try里的return不顶用吗
    
37.         }
    
38.         
    
39. }
    
40. class Test6
    
41. {
    
42.         public static void main(String[] args)
    
43.         {
    
44.                 int[] arr = {1,4,76,5};
    
45.                 Max m = new Max();
    
46.                 System.out.println(m.da(arr,6));
    
47.         }
    
48. }
    

复制代码

是我return没有听懂还是怎么了

应该是改变的是m不是return

{:soso_e134:}不是太明白
因为执行return顺序在finnally之前啊。
不是说了么？
先执行try里面语句。如果不碰到异常的话，都会执行完。
再执行finnally。所以返回值没改变。m的值确实是改变了。
不会是在finnally中加return吧

殇_心。 发表于 2013-4-18 11:20
因为return执行顺序在finnally之前啊。
不是说了么？
先执行try里面语句。如果不碰到异常的话，都会执行 ...

我想说的是：他题目不是说finally语句不能改变return的返回值吗，那么我的returnValue刚开始时1000；
其他地方没有动，只有在finally中++了一次，返回的值就是1001了。。。

我理解是这样的

1. class Demo {
   
2.        
   
3.         public static void main(String []args){
   
4.                 System.out.println(funtion());
   
5.         }
   
6.         public static String funtion(){
   
7.                 /*return在finally之前，如果"开始finally"先出现，则证明return是在finally执行后才返回的
   
8.                 如果没有显示"我们开始return"，则证明finally无法改变返回值*/
   
9.                 try{
   
10.                         String s = "开始return";
    
11.                         return s;
    
12.                 }
    
13.                 finally{
    
14.                         System.out.println("开始finally");
    
15.                         String s = "我们开始return";
    
16.                 }
    
17.         }
    
18. }

复制代码

Miss小强 发表于 2013-4-18 11:14
这是我当时写的代码，说实话我对“且在finally无法改变返回值。”这句没怎么理解。。。我的程序是说明不 ...

因为return执行顺序在finnally之前啊。
不是说了么？
先执行try里面语句。如果不碰到异常的话，都会执行完。
再执行finnally。所以返回值没改变。m的值确实是改变了。

殇_心。 发表于 2013-4-18 10:48
拿你的例子说吧：
先运行try里面代码，如果有异常（try里面异常后面代码就不运行了）就运行catch。
你的try ...

1. public class Test7 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          *  写一个类证明return是在finally执行后才返回的，且在finally无法改变返回值。
   
6.          *  思路：说实话这句话的后一句不是很理解；
   
7.          *  安照输出情况，returnValue从1000变成1001；
   
8.          *  
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 System.out.println(test());
    
12.         }
    
13.         public static int test(){
    
14.                 int returnValue=1000;
    
15.                 try {
    
16.                         Thread.sleep(1000);
    
17.                        
    
18.                 } catch (InterruptedException e) {
    
19.                         // TODO Auto-generated catch block
    
20.                         e.printStackTrace();
    
21.                 }finally{
    
22.                         System.out.println(++returnValue);
    
23.                 }
    
24.                 return returnValue;
    
25.         }
    
26. 
    
27. }
    

复制代码

这是我当时写的代码，说实话我对“且在finally无法改变返回值。”这句没怎么理解。。。我的程序是说明不了这个问题的

拿你的例子说吧：
先运行try里面代码，如果有异常（try里面异常后面代码就不运行了）就运行catch。
你的try里面有个return 。 确实是返回了m值后，然后运行finnally。
因为finnally优先于线程的关闭。
所以主线程会等finnally这个代码块运行结束后，才会停止。