1. import java.util.concurrent.Callable;
   
2. 
   
3. public class Hello {
   
4.         public static void main(String[] args) {
   
5.                 System.out.println(tryTest());
   
6. 
   
7.         }
   
8.         public static String tryTest(){
   
9.                 String s=null;
   
10.                 try {
    
11.                         s="aa";
    
12.                         return s;
    
13.                 } finally {
    
14.                         s="bb";
    
15.                 }
    
16.         }
    
17. }

复制代码

为什么finally修改的值不会影响到返回值呢?

没返回，finally里加个return s。

1. public class Temp {
   
2.         public static void main(String[] args) {
   
3.                 System.out.println(tryTest());
   
4. 
   
5.         }
   
6.         public static String tryTest(){
   
7.                 String s=null;
   
8.                 try {
   
9.                         s="aa";
   
10.                         return s;
    
11.                 } finally {
    
12.                         s="bb";
    
13.                         return s;
    
14.                 }
    
15.         }
    
16. }

复制代码

你的代码貌似不能正常运行吧，这是有错误的，java规定，一个try后面必须至少接一个catch,可以不接finally，但是最多只能由一个finally,你的程序没有catch块，怎么能正常运行呢？剩下的事情楼上都说了，就是因为你的try里面已经写了return，当程序遇到return时，就会返回return后的变量的值，并且跳出函数，你的程序try中的return前没有错误，所以可以正常运行到return，这时函数中的剩余代码就不执行了

我用Eclipse里的Debug功能试了下，执行到return语句时没有直接返回，而是先去执行了finally里的语句，最后在返回来执行return s语句，至于finally修改的值不会影响到返回值，可能是在第一次执行到return s时，程序已经在内存里把return s(这时的s='aa')挂起来了，等到执行完finally里的语句时直接返回;

1. 
   
2. public class FinnallyDemo {
   
3.         public static void main(String[] args) {
   
4.                 System.out.println(tryTest());
   
5. 
   
6.         }
   
7.         public static String tryTest(){
   
8.                 String s=null;
   
9.                 try {
   
10.                         s="aa";
    
11.                         return test(s);
    
12. 
    
13.                 } finally {
    
14.                         s="bb";
    
15.                                                 System.out.println("执行了finally");
    
16.                                                 return s;//若这个return s没有，则不会覆盖s的值，还是原来的值
    
17.                 }       
    
18.         }
    
19.                 public static String test(String s){
    
20.                         System.out.println("test :");       
    
21. return s;
    
22.                 }
    
23. }

复制代码

执行过程分析：
1.try语句块，return test(s)，则调用test()方法
2.test()执行后返回s，返回值s保存在一个临时区域里
3.执行finally语句块。若finally语句有返回值，则此返回值将替换掉临时区域的返回值
4.将临时区域的返回值送到上一级方法中。

内存中是这样的
执行 return 的时候会在内存中有个returnValue 存储 返回值
s="aa";
return s;
这时returnValue 值已经是aa,但是还要执行finally语句中的语句,执行完后 s的值是bb,但是返回的是还是returnValue 所以是aa
可以参考对比2楼的例子,2楼中在
finally {
                        s="bb";
                        return s;
                }
此时returnValue 变为bb,再返回,这时try中的return就不在运行