黑马程序员技术交流社区

标题: 问个try catch 的问题 [打印本页]
作者: xuehuayous    时间: 2014-4-2 11:25
标题: 问个try catch 的问题
问什么返回的结果是2不是7啊？
  1. public class Test {

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

  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. }
复制代码




作者: 911趣购    时间: 2014-4-2 11:32
在静态方法中，因为k+=2就等于k=k+2------>k=2  然后就被返回了  ，剩下的就不执行了。所以在这里finally不会被执行  
作者: osully    时间: 2014-4-2 11:40
return 是用来结束函数用的,当都到return的时候,其实函数就要结束!..
但是finally的特点就是 没有System.exit(0)的情况,必然会运行.所以又在函数结束前运行一次finally...但是重点是return语句已经读过了!!!!

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


  1. public class Test {

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

  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. }
复制代码
作者: 青木郎    时间: 2014-4-2 12:00
和格式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
作者: anqi    时间: 2014-4-2 12:04
这个问题很经典，我也是云里雾里，查阅了不少内容，发现这竟然会在面试中考到。真是相互学习啊。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。




作者: 杨殿生    时间: 2014-4-2 12:24
本帖最后由 杨殿生 于 2014-4-2 12:29 编辑
  1. public class Test {
  2.          public static void main(String args[]){
  3.          System.out.println(kkk());
  4.          }

  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. }
复制代码


作者: 2528870651    时间: 2014-4-2 13:02
这个问题我以前问过类似的你可以看看
  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

  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. }
复制代码

作者: 元亨利贞    时间: 2014-4-2 13:10
执行到try里面，k=k+2=0+2=2,然后return出去了.
作者: Peach2014    时间: 2014-4-2 16:16
本帖最后由 Peach2014 于 2014-4-2 16:20 编辑

函数只能返回一次值，
在try中返回了k=2，所以，即便后面k值如何变化都不会对k=2这个事实造成影响。
作者: 赵小豪    时间: 2014-4-3 11:36
finally块中的语句不被执行的唯一情况：在异常处理代码中执行System.exit(1),将退出Java虚拟机。所以此题的答案为7.



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2