问什么返回的结果是2不是7啊？

1. public class Test {
   
2. 
   
3.          public static void main(String args[]){
   
4.          System.out.println(kkk());
   
5.          }
   
6. 
   
7.          public static int kkk(){
   
8.                  int k = 0;
   
9.                  try {
   
10.                          k += 2;
    
11.                          return k;
    
12.                  } catch(Exception e){
    
13.                          k++;
    
14.                          return k;
    
15.                  } finally {
    
16.                          k += 5;
    
17.                  }
    
18.          }
    
19. }

复制代码

在静态方法中，因为k+=2就等于k=k+2------>k=2  然后就被返回了  ，剩下的就不执行了。所以在这里finally不会被执行  

return 是用来结束函数用的,当都到return的时候,其实函数就要结束!..
但是finally的特点就是 没有System.exit(0)的情况,必然会运行.所以又在函数结束前运行一次finally...但是重点是return语句已经读过了!!!!

建议你这个看,你会更加明白

1. public class Test {
   
2. 
   
3.          public static void main(String args[]){
   
4.          System.out.println(kkk());
   
5.          }
   
6. 
   
7.          public static int kkk(){
   
8.                  int k = 0;
   
9.                  try {
   
10.                          k += 2;
    
11.                          return k;
    
12.                  } catch(Exception e){
    
13.                          k++;
    
14.                          return k;
    
15.                  } finally {
    
16.                          System.out.println(k += 5);
    
17.                  }
    
18.          }
    
19. }

复制代码

和格式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

这个问题很经典，我也是云里雾里，查阅了不少内容，发现这竟然会在面试中考到。真是相互学习啊。try语句和finally语句是2个代码块。他们互相不影响。下面的代码的结果是 语句1 语句2 3

1. try
   
2.                         {
   
3.                                 System.out.println("语句1");
   
4.                                 return 1;
   
5.                         }
   
6.                         catch (Exception e)
   
7.                         {
   
8.                                 return 2;
   
9.                         }
   
10.                         finally
    
11.                         {
    
12.                                 System.out.println("语句2");
    
13.                         }
    
14.         }
    
15. }
    

复制代码

意思是先执行完try语句中的内容，在执行finnally里面的内容，最后把return返回去，这里的return返回的仍然是try中的(相当于先保存起来)
经典的来了 如果finally语句中也有return ，比如上面的代码finally内加上return 3，我们会发现结果变成了3.
也就是说执行完try语句，在执行finnally语句遇到return直接就返回，不会再读try中的return。

1. public class Test {
   
2.          public static void main(String args[]){
   
3.          System.out.println(kkk());
   
4.          }
   
5. 
   
6.          public static int kkk(){
   
7.                  int k = 0;
   
8.                  try {
   
9.                          k += 2;
   
10.                         // return k; 在这个位置返回的k值为2
    
11.                  } catch(Exception e){
    
12.                          k++;
    
13.                         
    
14.                  } finally {
    
15.                          k += 5;
    
16.                          return k; //在这个位置返回的k值才为7这么修改就是7                     
    
17.                  }
    
18.          }
    
19. }

复制代码

这个问题我以前问过类似的你可以看看

1. class ExceptionTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int n = fun(2);
   
6.                 System.out.println("打印fun（）函数返回的n值=  "+n);
   
7.         }
   
8.         public static int fun(int i)
   
9.         {
   
10.                 try
    
11.                 {
    
12.                         int m= i/0;
    
13.                         return i++;
    
14.                 }
    
15.         
    
16.                 catch (ArithmeticException e)
    
17.                 {
    
18.                         System.out.println("异常信息："+e);
    
19.                         System.out.println("catch 中的i = "+i);
    
20.                         return i+3;   //返回的是 2+3， 而不是finally中对i的赋值再来加上3，
    
21.                                                         //finally中对i的操作，不会影响此时catch中的return i+3
    
22. 
    
23.                 }
    
24.                
    
25.                 finally
    
26.                 {
    
27.                         i++;
    
28.                         i++;
    
29.                         System.out.println("finally 执行  "+i);
    
30.                         //return i+8;   //如果这里没注释
    
31.                                                         //这里会返回12，而不会去返回catch中的  return i+3
    
32.                 }
    
33.         }
    
34. }
    

复制代码

执行到try里面，k=k+2=0+2=2,然后return出去了.

函数只能返回一次值，
在try中返回了k=2，所以，即便后面k值如何变化都不会对k=2这个事实造成影响。

finally块中的语句不被执行的唯一情况：在异常处理代码中执行System.exit(1),将退出Java虚拟机。所以此题的答案为7.