class Test4
{
        //public String output="";
        public C c=new C();
        public C foo(int i)
        {
                try
                {
                        if(i==1)
                                throw new Exception();         
                        c.msg+="1"; //throw  定义了语句编译也通过了？不是编译不通过吗？
                }
                catch(Exception e)
                {
                        c.msg+="2";
               
                        return c; //在内存中开避空间用为存储当前output值
                }
                finally
                {
                        c.msg+="3";
                        //System.out.println("output="+c.msg);
                }
                c.msg+="4";

                return c;
        }
        public static void main(String args[])
        {
                Test4 t=new Test4();
                 
                System.out.println(t.foo(1).msg); //23  
        }
}
class C
{
        String msg="";
}

打印：23
为什么不是 234？？

首先i==1,抛出异常，再执行catch里面的内容，msg=2；然后执行return，又有finally，最后执行finally,执行c.msg+="3"，所以打印的结果就是23了！

应该是catch 里面执行了return ， 所以直接返回了，没有执行c.msg+="4";   而finally是必须执行的，应该是这样吧？

在if(i==1)
         throw new Exception();   
已经跑出异常了，函数已经终止了就不会接下去走了，就只会运行  catch(Exception e)和  finally中的代码。
即使你的代码catch了。

i==1,符合条件抛出异常，catch捕获异常,运行c.msg+="2",得到c.msg="2",按一般情况应该是返回c的,但是后面finally是必须要执行的,运行 c.msg+="3"后再返回c,所以得到23

在这里
if(i==1)
        throw new Exception();         
c.msg+="1"; //throw  定义了语句编译也通过了？不是编译不通过吗？
因为throw语句前面有个if判断语句，所以c.msg+="1";这句话在if为假的情况下可以执行的到，所以编译通过。
在打印语句中t.foo(1)执行的是try块中的语句，等于1抛出了一个异常c.msg+="1"没有执行到。这个异常被
捕获后执行c.msg+="2"，并返回c，程序结束，由于finally中语句始终会执行，所以c.msg+="3"也会执行，
下面的代码将不再执行，所以msg的值是23

class Test4 {
        // public String output="";
        public C c = new C();

        public C foo(int i) {
                try {
                        if (i == 1)
                                throw new Exception();
                        c.msg += "1"; // throw 定义了语句编译也通过了？不是编译不通过吗？

                        // 上面能通过 他一个省略语句，省略了一对大括号：try {if (i == 1){throw new  Exception();}c.msg += "1";}
                       
                } catch (Exception e) {
                        c.msg += "2";

                        return c; // 在内存中开避空间用为存储当前output值
                } finally {
                        c.msg += "3";  //这里运行完了，就会去运行上面的 return c,然后退出返回，下面的 c.msg += "4";  return c; 不会执行了，
                       
                                                        //所以结果是：23
                }
                c.msg += "4";

                return c;
        }

        public static void main(String args[]) {
                Test4 t = new Test4();

                System.out.println(t.foo(1).msg); // 23
        }
}

class C {
        String msg = "";
}

    try
                {
                        if(i==1)
                                throw new Exception();         
                        c.msg+="1"; //throw  定义了语句编译也通过了？不是编译不通过吗？
                }
                catch(Exception e)
                {
                        c.msg+="2";
               
                        return c;

//这段代码，try  throw  catch
听老师讲的比较有意思，如果你直接写throw 直接抛的话，你还要在调用你的地方进行捕获或者继续抛
但是这段代码是   你在这里抛出异常，catch直接捕获，也就是自己抛异常自己捕获异常，throw抛出
catch捕获直接自己处理 运行catch里的代码   所以打印了 “2”
finally是不管你前边结果怎样都运行，除非碰到System.exit(0); 执行完再执行return
所以，打印  23

这种写法我们实际开发用的不多，在笔试题里比较常见。

进入catch 打印2  然后他执行return，但是程序有finally，所以finally里的也会执行并return，外面代码将不会再执行，如果没有异常的话
就是134

这个题考异常流程，
原题是：
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);//134
                foo(1);
                System.out.println(output); //13423
        }
}