public static int tryfinally()
        {
                try
                {
                        return 1;
                }
                finally
                {
                        return 2;
                }
        }

这个问题的返回值怎么成2了？？？
我记得第一次碰到这个问题，我以为是2 的时候，别人告诉我说是1，
try和finally同事有返回值时，返回try
可是刚刚调试的时候，发现返回的是finally里面的值
求高手解释一下

无论try里面怎么样做了，程序运行到结尾必须要运行一下finally代码块里面的代码。这点毕老师在视频里不是将过么：finally代码块，必须走一遍。所以可以用他关闭数据流。

其实这个很简单啦，楼主只要记住try-finally系列的语句，finally语句块的内容总是要被执行就好了，所以嘛，最后的结果就是2了。程序中return语句有强制方法结束的作用，但是也一定会去执行finally块里的代码。当然啦，老师给我说，在finally块里面要尽量避免使用这种会导致方法终止的语句，会出现一些奇怪的现象，所以这种方式以后还是尽量避免吧

这个要分析内存，你就明白了，给你一个程序，你看一下就明白了，重点是第一个return的分析。

1. public class Test7 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 //创建本类对象
   
5.                 Test7 test = new Test7();
   
6.                
   
7.                 //执行prove方法
   
8.                 test.prove();
   
9.         }
   
10. 
    
11.         public String prove() {
    
12.                 try {
    
13.                         System.out.println("try语句开始");//这句话证明prove方法开始执行，打印"try语句开始"
    
14.                        
    
15.                         //定义return语句，执行过程如下分析。
    
16.                         return m1(); /*  此时m1方法开始执行，打印"m1方法开始"，m1方法退出。m1方法退出后，该return正要执行，退出prove方法，
    
17.                                                     发现prove方法存在finally代码块，所以此时return并没有执行，而是执行fianlly代码块后中的内容，打印
    
18.                                                  "m2方法开始"，m2方法退出，finally代码块也执行完了。此时才执行return，退出prove方法。   */
    
19.                 }finally {
    
20.                         m2();
    
21.                 }
    
22.         }
    
23.        
    
24.         public String m1() {
    
25.                 System.out.println("m1方法开始");
    
26.                 return null;
    
27.         }
    
28.        
    
29.         public void m2() {
    
30.                 System.out.println("m2方法开始");
    
31.         }
    
32. }
    

复制代码

public class Test {

         public static void main(String args[]){
         System.out.println(kkk());
         }

         public static int kkk(){
                 int k = 0;
                 try {
                         k += 2;
                         return k;
                 } catch(Exception e){
                         k++;
                         return k;
                 } finally {
                         k += 5;
                 }
         }
}
这个是返回的是2？为什么不是7呢？
    因为finally里面不是return语句，是的话就是7了。




和格式try 和finally的执行顺序问题：
程序会先执行try的语句，如果try遇到exception或者error后，执行catch中的语句，最后执行finally中的语句
程序在try中遇到return语句后，会将return的结果存在一个缓存中，但是并不会直接就输出，而是先储存起来，等到finally执行完毕后才输出return结果，接入finally中也有return语句，那么就会覆盖掉try中的return值，
public class Test {

         public static void main(String args[]){
         System.out.println(kkk());
         }

         public static int kkk(){
                 int k = 0;
                 try {
                         k += 2;
                         return k;
                 } catch(Exception e){
                         k++;
                         return k;
                 } finally {
                         System.out.println(k += 5);
                        return k;
                 }
         }
}
这个时候结果就会是7

kuroro自走核炮 发表于 2014-4-25 11:04
无论try里面怎么样做了，程序运行到结尾必须要运行一下finally代码块里面的代码。这点毕老师在视频里不是将 ...

  try {
                         k += 2;
                         return k;
                 } catch(Exception e){
                         k++;
                         return k;
                 } finally {
                         k += 5;
                 }
亲，那你觉得这个返回的是几？？

Ricky_Nick 发表于 2014-4-25 15:12
try {
                         k += 2;
                         return k;

如果你这是个传入int k然后进行计算的方法，那么传回去的k是k+2，因为finally不影响这个方法返回值了。
如果在finally代码块中又添加一个return k，那么传回去的就是k+2+5，就是k+7。

1. class Testk
   
2. {
   
3.     public static void main(String[] args)
   
4.     {
   
5.         int k = 0;
   
6.         int x = getback(k);
   
7.         System.out.println(x);
   
8. 
   
9.     }
   
10.         public static int getback(int k)
    
11.         {     
    
12.                 try
    
13.                         {
    
14.                          k += 2;
    
15.                          return k;
    
16.                  } catch(Exception e){
    
17.                          k++;
    
18.                          return k; //这两行被try代码块中的return跳过了，所以不执行。
    
19.                  } finally {
    
20.                          k += 5;
    
21.                                                  return k;//不写这句，打印2，写这句，打印7。
    
22.                  }
    
23.         )
    
24. }

复制代码

这个就是我测试用的代码。

顺便再给你举个栗子解释一下吧
情况一：
try {
                         k += 2; //我烧了一锅排骨
                         return k; //给你盛了一碗
                 } catch(Exception e){
                         k++;
                         return k;
                 } finally {
                         k += 5; //我在锅里加了辣椒
                 }
情况二：
try {
                         k += 2; //我烧了一锅排骨
                         return k; //给你盛了一碗
                 } catch(Exception e){
                         k++;
                         return k;
                 } finally {
                         k += 5; //我在锅里加了辣椒
                        return k；//我重新给你盛了一碗
                 }
好，那么你在情况一和情况二吃到的排骨哪个是辣的哪个是不辣的？

finally里面的语句是一定会执行的。像在你的程序了，程序是这样执行的：
先执行try里的语句，但是遇到return话会看是否有finally块，有的话先不return,就先执行finally里的语句。如果在finally里也遇到了return,就会跳回try里先执行try的return,然后再执行finally的retrun,这样的话就会把前面try里return的值给覆盖了。你可以用下面的代码测试一下。

1. public class Test {  
   
2.         public static void main(String[] args) throws Exception {   \
   
3.                  foo();  }   
   
4.         static int foo() throws Exception {   
   
5.          try {  System.out.println("1");      
   
6.                 System.exit(1);      
   
7.                 System.out.println("2");      
   
8.                 return 2;   
   
9.                 }
   
10.         finally {      
    
11.                 System.out.println("3");   
    
12.                  }  
    
13.         }
    
14. }

复制代码