1. public class  smallT
   
2. {
   
3.         public static void  main(String args[])
   
4.         {
   
5.                 smallT t  = new  smallT();
   
6.                 int  b  =  t.get();
   
7.                 System.out.println(b);
   
8.         }
   
9.        
   
10.         public int  get()
    
11.         {
    
12.                 try
    
13.                 {
    
14.                         return 1 ;
    
15.                 }
    
16.                 finally
    
17.                 {
    
18.                         return 2 ;
    
19.                 }
    
20.         }
    
21. }
    

复制代码

      这题也是在某公司笔试时见到过的,当时那题还比这个难,有5,6个RETURN,这题在两个返回句上面写两个输出测试下就能看到走向了.
      因为有时候程序在try块里打开一些物理资源,这个资源是要显式回收的.GC是不会回收物理资源的.其只能回收堆内存中对象所占内存.所以异常处理机制才提供finally来回收,上面就是这个情况，所以return 1不执行.finally总会被执行.

再try中finally时一定要执行的，但是return是跳转语句，当try中的return执行时，这个程序已经结束了。

public class ExceptionTest {

        public static void main(String[] args) {
                ExceptionTest et = new ExceptionTest();
                int b = et.get();
                System.out.println(b);
        }
         public int  get()
     {
             try
             {
                     int i = 1/0;
                     return 1 ;
             }
             catch(Exception ex){
                     return 3;
             }
             finally
             {
                     return 2 ;//无论如何都要执行，遇到return就会把结果返回，不会接着执行其他的return了。无论是try中的还是catch中的return。
                    // System.out.println("finally");//如果不是return，则执行完该语句，继续执行其他的return,如果有异常执行catch中return，没异常执行try中的retrun
             }
     }
}

结果是2：
原因： try catch 块里 最后一定会执行finally块，当执行到try块的return语句之前会先执行finally块的return语句，此时函数结束！返回值就是2
回答完毕！

额  我的基础 测试题是这样的    你们看看
8、 写一个类证明return是在finally执行后才返回的，且在finally无法改变返回值。

return 只是返回一个值，起不到中断的效果，而finally是必须要执行的，他们的顺序如下，不中的我理解对了没！希望大家指正。

当try时，在栈内存中产生一个对象句柄b，
然后在堆内存中产生一片空间，该空间的值就是1，
对象句柄b就指向了该空间，
这时候finally执行了，在堆内存中又产生了一个空间值为2
对象句柄b就指向了值为2的这个空间地址，
所以结果打印的是2

因为finally中定义的是一定会被执行的代码，当你执行try{}里面的语句时，就已经确定了，你肯定要执行finally里面的语句（如果是try finally模式），finally只有在一种情况下不被执行
那就是在
try{
     System.exit(0);
}//这里就执行了关闭jvm的命令。我还去验证了一下，真 没有返回值。

finally肯定执行，答案是2

其实呢。我们可以这么来：
代码改一下：

1. public class  smallT
   
2. {
   
3.         public static void  main(String args[])
   
4.         {
   
5.                 smallT t  = new  smallT();
   
6.                 int  b  =  t.get();
   
7.                 System.out.println(b);
   
8.         }
   
9.         
   
10.         public int  get()
    
11.         {
    
12.                 int c;
    
13.                 try
    
14.                 {
    
15.                                  c=1;
    
16.                                 System.out.println(c);
    
17.                                 return c ;
    
18.                 }
    
19.                 finally
    
20.                 {
    
21.                                 c = 2;
    
22.                                 System.out.println(c);
    
23.                                 return c;                        
    
24.                 }
    
25.         }
    
26. }
    

复制代码

如此一来我们可以可以做以下步骤：
1.把finally中的return语句注释掉。发现输出的结果是：1  2  1。这样就可以知道，try有把 1 返还给b，此时 c 的值为 1。但是经过finally中的赋值，c 的值为2。
2.打开finally中的return语句。发现输出的结果是：1  2  2。这样我们就可以知道：b的值最终是finally返回给他的值，也就是 2。
所以我们就可以知道：
t.get();调用get()函数，先执行try语句，将 1 返回，此时值为 1。接着执行finally语句，将 2 返回，此时值为 2。所以最终的值为2。
把t.get()的值赋给 b，b 的值自然就是2.

输出结果为2，因为finally是一定要执行的。
当try语句块中有return语句时，
执行的流程如下：
在方法返回前，finally中语句先执行，如果finally中
也有return语句，那么这个返回值将会被覆盖。
如此题所述，最后的执行结果一定是2.
回答结束！请参考！

finally中return中值覆盖掉了try中的值