一道考试题，求分享过程。。。。

结果输出字符串：
134
23

虎牛龙马 发表于 2014-4-14 21:28
结果输出字符串：
134
23

可以详解不？我不是要答案的。如果只是答案我早就编译了

1. public class Dome {
   
2.         public static String cutput="";
   
3.         public static void foo(int i)
   
4.         {
   
5.                 try {
   
6.                         if (i==1)     
   
7.                                 throw new Exception();       //   foo(1)   2   
   
8.                         cutput+="1"; //foo(0)  2
   
9.                 } catch (Exception e) {
   
10.                         cutput +="2";                    //foo(1)   3
    
11.                         return;                                                         //foo(1)   5   遇到return直接结束方法了， 不执行cutput+="4";
    
12.                 }
    
13.                 finally
    
14.                 {
    
15.                         cutput+="3"; //foo(0)   3        //foo(1)   4
    
16.                 }
    
17.                 cutput+="4"; //foo(0)   4
    
18.         }
    
19.         public static void main(String[] agrs)
    
20.         {
    
21.                 foo(0);  //foo(0)   1          执行顺序你看一下      
    
22.                 System.out.println(cutput);  //  1+3+4=134
    
23.                 foo(1); //foo(1)   1
    
24.                 System.out.println(cutput);   //134+2++3=13423
    
25.         }
    
26. }
    

复制代码

结果是：
134
13423
你看能不能看得懂     我也是新手    不知道对不对

执行结果：
134
13423

foo（0）
先执行try里面代码：output+=“1”；这时output=“1”；因为if为假异常抛不出去，所以catch捕捉不到也不能执行。但是finally是一定执行的代码，所以这时output=“13”；程序继续下走，执行output+=“4”；结束foo方法。输出字符串“134”；
在执行 foo（1）；  ！！（此时的output=“134”）
if成立，抛出异常，catch捕捉，执行output+=“2”，output=“1342”，然后执行return，结束。但是finally是一定会执行的语句，所以还要执行一个output+=“3”，output=“13423”，foo方法结束，输出字符串“13423”。

foo(0):先判断，i == 0 所以 ！= 1，不执行throw 那句，直接执行output+=“1”；然后，finally语句是try catch 语句块始终要执行的，故再+“3”，这就执行完了try catch语句块，之后执行下面的一句代码块之外的语句 outp+=“4”，故第一个输出为 134； 而foo(1)，在if判断时，为真，执行throw语句抛出异常，不再执行+“1”语句，系统开始处理异常，catch语句执行，抓取到这个异常，执行output+=“2”语句，然后退出try catch语句块，直接返回了(但是finally语句在退出try catch时回自动执行，故结果是 23)

调用代码：
foo(0)
syso(output);
foo(1)
syso(output);
执行过程：
1，调用foo(0)，此时i==0，执行try模块中的output+="1"，此时的output为“1”；由于没有异常抛出，catch模块不执行；但是finally模块是必须执行的，所以执行完finally模块后output为“13”；执行完上面语句后，接着执行output+=“4”；所以，第一次调用foo(0),打印结果是：134。
2，调用foo(1) , 此时i==1，满足if条件，抛出异常；此时catch模块捕捉到异常，执行catch模块语句，完后output为“2”，由于catch中有return语句，此语句是用来结束被调用的方法foo(1)的，但是在结束此方法之前finally模块会强制执行，所以等到foo(1)调用完毕之后，打印output为 : 23。
3，补充一点，在第2步的中，要像不执行finally模块，可以在return语句后面加一句System.exit(0)，此语句是用来强制停止JVM的运行的。所以最后的finally模块是执行不到的。

答案是  134   13423 这个题老师见过了 不要误导
  foo(1); //foo(1)   
                System.out.println(cutput);  
当这个代码执行的时候是第2个了他之前的值是134 。然后在次打印应该是在134的基础上再次打印 也就是13423.
因为是字符串所以就是要这样打印而不是相加

输出结果：134
               13434
（1）public static String output =""在Test类中定义的一个字符串对象是一个静态的作用与全局的变量。
第一次调用函数：将参数传递给public staitc void foo(int i)函数中，先执行if(i==1)语句（0!=1），在if语句没有定义语句块时，只执行if语句后的第一条语句，也就output+=“1”,好了现在output对象中的字符串编程了“1”，然后执行finally｛output+=“3”;｝（finally语句被称为不论如何都要被执行的）这条语句相当于是在将字符串中的1，3合并成了一个字符串，也就是“13”最后执行output+=“4”；最后output对象中的字符串的值就被改变成了“134”；因为（1）的关系所以在System.out.println(output)的输出结果就为"134";
第二次调用时因为(1)的关系output的值是“134”，在用foo(1)调用时，因为if(i==1)那么output+=1不会执行，
然后执行的是catch{output+=3;},（此时output的引用指向的字符串对象是"1343",)继续执行return；在执行的return；时相当于要结束这次调用，但是在finally语句中的语句块中的代码必须执行，所以return就暂时等在了那，接着执行finall{output+=3;},此时的output引用指向的字符串对象的值就变成了“13434”。
这就是步骤：代码如下：

1. 
   
2. public class NewTest {
   
3.      public static String output = "";
   
4.      
   
5.      public static void foo(int i){
   
6.              try{
   
7.                      if(i==1)
   
8.                             throw new Exception();
   
9.                              output+=1;
   
10.                         
    
11.                      
    
12.              }catch(Exception e){
    
13.                      
    
14.                       output+=2;
    
15.                       return;
    
16.                      
    
17.              }finally{
    
18.                      
    
19.                      output+=3;
    
20.                      
    
21.                      
    
22.              }
    
23.              
    
24.              
    
25.               output+=4;
    
26.      }
    
27.         /**
    
28.          * @param args
    
29.          */
    
30.         public static void main(String[] args) {
    
31.                 // TODO Auto-generated method stub
    
32.              foo(0);
    
33.              System.out.println("output1="+output);
    
34.              foo(1);
    
35.              System.out.println("output2="+output);
    
36.         }
    
37. 
    
38. }
    

复制代码

/*我编译的代码输出的结果为：output1=134
                                       ：output2=13423
*/

第一次传入0，if不满足，所以output=“1”，finally一定会执行，所以output = output+"3",也就是output="1"+"3"=="13",此时未报异常，所以程序继续执行，output = output + "4"=="13"+"4"=="134",重点就在这里，output是static，所以output是共享数据，第二次创建对象的时候，output的值为"134".此时，foo(1)，if条件满足抛出异常，此处try中下面的语句就不会执行了，直接执行catch中的代码，也就是output = output + "2"=="134" + "2" =="1342",finally中的代码一定会执行，output = output + "3" == "1342" + "3" == "13423"
所以两天输出语句的结果分别是134和13423，希望你能明白

demown 发表于 2014-4-14 22:15
答案是  134   13423 这个题老师见过了 不要误导
  foo(1); //foo(1)   
                System.out.print ...

这个结果是对的，我没有注意到成员变量，不过，我的过程没错！