class Test
{
        public static String output="";
        public static void foo(int i)
        {
                try
                {
                        if(i==1)
                                throw new Exception();        
                        output+="1";
                }
                catch(Exception e)
                {
                        output+="2";
                        return;
                }
                finally
                {
                        output+="3";
                }
                output+="4";
        }
        public static void main(String args[])
        {
                foo(0);
                System.out.println(output);
                foo(1);
                System.out.println(output);
        }
}

输出结果134
            13423
因为output是静态的全局变量

134
13423
其实我很想知道你问的是什么  不应该只是一个输出结果吧？

   我想知道为什么是
          134
                13423
             所以就问问咯 。

因为i=0，所以不报异常正常执行，try……finally 直至程序末尾134.
因为output是static的，所以在调用foo(1)之前，output是134，
因为i=1，抛出异常，if(i==1)   throw new Exception();后面的语句output+="1"; 不执行，跳到catch中
output=1342,运行到return语句，发现还有finally语句，就先不执行return语句。而执行finally语句output=13423,执行完finally就执行return语句。

1. class Test {
   
2.         public static String output = "";
   
3. 
   
4.         public static void foo(int i) {
   
5.                 try {
   
6.                         if (i == 1)
   
7.                                 throw new Exception();//第一遍不满足条件，不执行这部分代码
   
8.                                                                                                          //因为第二遍时参数i的值为1，满足if条件，所以执行这部分代码，跳转到catch代码块中
   
9.                         output += "1";//第一遍的这行结果output="1"
   
10.                                                                      //第二遍时由于上面抛出异常跳转了，这句代码不再执行
    
11.                 } catch (Exception e) {
    
12.                         output += "2";//第二遍出现异常，跳转到这里，所以output="1342"
    
13.                         return;//第二遍：而这里比较关键，出现return，那么很快你要和这个方法说拜拜了
    
14.                 } finally {
    
15.                         output += "3";//finally中的代码不管有没有异常都要执行，所以第一遍的这行output="13"
    
16.                                                                      //虽然前面代码中出现return，但管我finally啥事那，打死我都执行，所以output="13423"
    
17.                 }
    
18.                 output += "4";//而这里，是在foo()方法中的，没有遇到跳出结束等关键字，所以第一遍时这行代码要执行，这时output="134"
    
19.                                                              //第二遍：前文提到return了，这时就跟这个方法说再见吧，所以这行在foo()中的代码就甭管它了
    
20.         }
    
21. 
    
22.         public static void main(String args[]) {
    
23.                 foo(0);//第一遍：综上所诉，结果为134
    
24.                 System.out.println(output);//注意这时output已经是134了，原因是static
    
25.                 foo(1);//第二遍：综上所诉，结果为13423
    
26.                 System.out.println(output);
    
27.         }
    
28. }

复制代码

foo(0)时：if()括号里面为false，不抛异常，不执行catch()语句。执行output+="1"----->finally语句:output+="3";
------->output+="4"; 所以结果为 134
foo(1)时：if()括号里面为true，抛异常，执行catch()语句。执行output+="2"----->finally语句:output+="3";
加上foo(0)执行后output结果为 134，最终结果就是 13423