class  Demo
{
           public  static  void  func()
           {
                   throw new Exception();     //把异常抛出，不久该catch了吗？
                   System.out.println("A");        
           }
           catch(Exception e)
           {
                  System.out.println("B");
           }
           public static  void main(String args[])
           {
                    try
                    {
                               func();
                    }
                    catch(Exception e)
                    {
                               System.out.println("c");
                    }
                     System.out.println("D");
         }
}
结果不应该是B D吗？为什么会编译失败？

1. 
   
2. class Demo {
   
3. public static void func() {
   
4.   try {
   
5.    throw new Exception(); // 把异常抛出，不久该catch了吗？
   
6.    // System.out.println("A");//编译失败，因为打印"A"的输出语句执行不到。
   
7.   } catch (Exception e) {
   
8.    System.out.println("B");
   
9.   }
   
10. }
    
11. public static void main(String args[]) {
    
12.   try {
    
13.    func();
    
14.   } catch (Exception e) {
    
15.    System.out.println("C");
    
16.   }
    
17.   System.out.println("D");
    
18. }
    
19. }
    

复制代码

代码有点问题，你都没try就catch了，这个是毕老师day10里的第16个练习，
主函数中调用func()方法，其中抛出了异常，下面的语句永远不会被执行到，所以会编译报错，
注释掉后，有相对的catch处理方法打印B，回到主函数，try中全部执行了问题在func()中已经解决了，
就不执行主函数的catch了，然后接着执行打印D，最后就是打印B D了。

class  Demo
{
           public  static  void  func()
           {
                   throw new Exception();     //在此处你应该将其放到try语句里
                   System.out.println("A");        
           }
           catch(Exeption e)
           {
                  System.out.println("B");
           }
           public static  void main(String args[])
           {
                    try
                    {
                               func();
                    }
                    catch(Exception e)
                    {
                               System.out.println("c");
                    }
                     System.out.println("D");//要想始终都让它输出你应该将其放到finally语句之中，注意finally语句常用来关闭资源的。java程序在执行try{}catch{}时遇到return或是throw语句，都将会导致该方法立即结束，但是系统执行这两条语句并不会结束该方法，而是去寻找该异常处理流程中是否含有finally块要是没有程序就会马上执行return或throw语句方法终止，若有finally块系统就立即执行该块，只有执行完该块后系统才会再次跳回来执行try{}catch{}块中的return或throw语句；
         }
}

记住在java中有try{}catch{}
也有try{}finally{}
还有try{}catch{}finally{}
一般都不会将catch专门独自使用。其一般都是和try放在一起使用
就像毕老师讲的当出现异常时，你可以选择将其抛出去，也可以使用try{}catch{}语句来解决！

class  Demo
{
           public  static  void  func()
           {
                   throw new Exception();     //把异常抛出，不久该catch了吗？
                   System.out.println("A");        
           }
           catch(Exeption e)
           {
                  System.out.println("B");
           }
           public static  void main(String args[])
           {
                    try
                    {
                               func();
                    }
                    catch(Exception e)
                    {
                               System.out.println("c");
                    }
                     System.out.println("D");/要想让其执行应该将其放到finally语句之中，注意java在执行try--catch语句时遇到return或是throw语句就会导致该方法立即结束，但是系统执行这两条语句并不会结束方法，而是去寻找，该异常处理流程中是否包含finally语句；
要是没有就会立即执行return或throw语句，要是有就会跳去执行finally语句知道该语句执行结束之后，程序才会再一次跳转到try--catch块中执return或是throw语句。
在java中有try{}catch{}
还有try{}finally{}
和try{}catch{}finally{}
一般不会将catch单独使用。
在处理异常时就像毕老师讲的你可以选择抛或是使用try--catch；
         }
}

你的错误：
1编译错误，你catch(Exception e) 写成 catch(Exeption e)去了
2catch应该说不能自己单独出现吧，我知道try出现可以不一定用catch，因为try可以和finally一起用，但是catch之前必须得有try才能捕获啊
3 throw是丢出一个你自己定义的异常，让其他程序调用这个方法时运行到你抛出新异常的地方，会接收到你的新异常。并不是你这样，像定义方法一样，随便就能catch到的
4 throw new Exception一般是用来在catch里面，捕获到异常后，如果你想由调用这个函数的程序来处理，可以throw一个new Exception
你的代码有点儿混乱，不太好修改，如果非要修改，注释掉那个catch方法，再在throw new Exception的方法申明throws Exception，最后注释掉throw new Exception后
才能运行，结果输出为：C D

class test
{
           public  static  void  func() throws Exception  //声明抛出的异常
           {
                   throw new Exception();     //把异常抛出，不久该catch了吗？  应该是给调用这个的方法的 主调方去处理 如果主调方也不想处理 则可以继续往外抛
                   //System.out.println("A");    //在这句话之前已经明确的说异常抛出了，这里的代码将不会被执行
                   //所以编译不能通过           }
          /* catch(Exception e)
           {
                  System.out.println("B");  这里的代码放在类体里面？？没见过
           }*/  
           public static  void main(String args[])
           {
                    try
                    {
                           func();
                    }
                    catch(Exception e)
                    {
                               System.out.println("c");
                    }
                     System.out.println("D");
         }
}

class  Demo
{
           public  static  void  func()
           {
                   throw new Exception();     //把异常抛出，不久该catch了吗？
                   System.out.println("A");     //由于前面有抛出异常的动作，这一句话一定执行不到，属于垃圾语句，所以在编译的时候就会报错  
           }
           catch(Exception e)
           {
                  System.out.println("B");
           }
           public static  void main(String args[])
           {
                    try
                    {
                               func();
                    }
                    catch(Exception e)
                    {
                               System.out.println("c");
                    }
                     System.out.println("D");
         }
}

但是我们把代码稍微修改一下就能够变异通过
class  Demo
{
           public  static  void  func()
           {
                   show();   //调用抛出异常的方法
                   System.out.println("A");        
           }
           //把抛出异常单独定义到方法中
           public static void show()
           {
                    throw new Exception();     
           }
           catch(Exception e)
           {
                  System.out.println("B");
           }
           public static  void main(String args[])
           {
                    try
                    {
                               func();
                    }
                    catch(Exception e)
                    {
                               System.out.println("c");
                    }
                     System.out.println("D");
         }
}

这个为什么能通过呢？
虽然都是抛出异常，当这个方法定义在方法中，被调用的时候，它下面的语句有可能被执行到，
因为调用方法下面的语句在虚拟机看来可能被执行到，不会出现垃圾语句，所以就会通过

要么try｛｝catch（）｛｝
要么try｛｝finally｛｝
要么try｛｝catch（）｛｝finally
木有见过直接catch｛｝的