class Demo

{       
        public static void func() //throws Exception  // 这个程序有点怪异了哦  
        {
                try
                {
                        throw  new Exception();
                }
                catch(Exception e)
                {
                        System.out.println("A");

                }
               

        }
        public static void main(String[] args)
        {
                try
                {
                        func();
                        System.out.println("A");
                }
                catch(Exception e)
                {
                        System.out.println("C");
                }
                System.out.println("D");
        }
}

这个程序的输出结果是AAD  为什么？  最重要的是它没有编译失败

你手动抛的异常catch也会抓住的。{:soso_e127:}

因为主函数先走try代码块里面的语句，第一条语句是func()方法，func()方法里面try代码块的语句是声明抛出异常，这个异常直接就在方法内部解决所以走catch代码块里面的语句，输出A，之后主程序继续走，又输出一个A，因为没有发生异常，所以不走catch代码块的语句，最后输出D，所以最后结果是AAD

程序相当这样：

        public static void main(String[] args)
        {
                try
                {
                    try
                     {
                             throw  new Exception();
                     }
                     catch(Exception e)     //捕捉到一个异常，执行打印“A”
                     {
                            System.out.println("A");
                       }
                        System.out.println("A");    //程序继续执行，打印“A”，并没有抛出异常
                }
                catch(Exception e)    //没有异常，这里不执行
                {
                        System.out.println("C");
                }
                System.out.println("D");    //程序继续，打印“D”，所以记过是AAD
        }

通过throw抛出异常后，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要跑出的异常；如果要捕捉throw抛出的异常，则必须使用try—catch语句。

所以当程序执行到throw的时候，会先停下来，去catch中捕获处理异常，并打印A。然后继续往下执行。继续打印A。这个时候没有异常了，最后打印D

1. {        
   
2.         public static void func()
   
3.          {
   
4.                  try    //异常在内部处理后，就没有再声明异常
   
5.                  {
   
6.                          throw  new Exception();
   
7.                  }
   
8.                  catch(Exception e)  //处理过程中，没有抛出任何异常
   
9.                  {
   
10.                          System.out.println("A");
    
11. 
    
12.                 }
    
13.                  
    
14. 
    
15.         }
    
16.          public static void main(String[] args)
    
17.          {
    
18.                  try
    
19.                  {
    
20.                          func();    //正常运行
    
21.                          System.out.println("A");
    
22.                  }
    
23.                  catch(Exception e)     //不需要捕捉,跳过
    
24. 
    
25.                  {
    
26.                          System.out.println("C");         
    
27.                  }
    
28.                  System.out.println("D");  //最后执行
    
29.          }
    
30. }
    
31. 
    

复制代码

wyl530274554 发表于 2012-6-11 22:04

  谢谢你  

伊文龙 发表于 2012-6-11 21:54
你手动抛的异常catch也会抓住的。

  这里好像不是这个问题吧  我主要想问的是在函数内部抛出了异常  却没有在函数外部声明  编译也能通过  现在已经知道答案了  嘻嘻

这个很好理解啊！
主函数先执行try代码块里面的语句
第一条语句是func()方法，而func()方法里面try代码块的语句是声明抛出异常，然后catch语句 输出A
继续执行主函数，输出一个A
因为没有发生异常，不执行catch代码块的语句
finally 打印输出D
最后结果是AAD

class Demo

{      
        public static void func() //throws Exception  // 这个程序有点怪异了哦  
        {
                try
                {
                        throw  new Exception();//抛出异常对象,new Exception(); 函数内部有catch自动处理
                }
                catch(Exception e)//处理的结果就是:打印"A"
                {
                        System.out.println("A");

                }
               

        }
        public static void main(String[] args)
        {
                try//由于调用 func()函数时候抛出的异常,被func()本身已处理.所以次try没有抛出任何异常
                {
                        func();//此函数运行完打印A,
                        System.out.println("A");//接着打印A
                }
                catch(Exception e)//由于try没有抛出异常,所以catch没有执行
                {
                        System.out.println("C");
                }
                System.out.println("D");//最后打印D
        }
                //最后结果是:A
           //                    A
          //                         D
}