昨晚看公开课才发现原来抛出异常有两种，throw和throws
throw在方法内部抛出一个具体的异常，throw new RuntimeException("XXX");
throws在方法声明中抛出多个异常， public void exceptionDemo() throws Exception {}
我想问的是怎么来捕获多个异常？还有throws能在类的声明中使用么?

1. class FuShuException extends Exception
   
2. {
   
3.                 FuShuException(String msg)
   
4.                {
   
5.                    super(msg);
   
6.                }
   
7. }
   
8. 
   
9. class Demo
   
10. {
    
11.                      int div(int a,int b)throws FuShuException//给方法定义数据类型,因为方法里头有返回值.然后抛出付出异常.
    
12.                     {
    
13.                            if(b<0)
    
14.                            throw new FuShuException("除数为负数");
    
15.                             return a/b;//注意这里有返回值.所以在方法名前面需要返回值类型 int div
    
16.                    }
    
17. }

复制代码

我给你在自学视频中遇到的.按我的理解,如果你想在方法内抛出异常,那么在方法名后需要声明throws(异常方法)
也就是说一个方法内
方法内:只要有throw
方法名后面:必须有throws
这两者是连接的.这个是按我个人的话来理解的.如有不对,请指出!谢谢!

关于throw和throws的分析及对异常的捕获：
1，声明或抛出异常有两种方法：
     A 用关键字 throws 在声明方法或函数时抛出可能存在的异常，一个或者多个，多个时用逗号隔开。如：
         public void hah( ) throws AException,BException
         {

          }
        声明了有异常的函数或方法，在其它程序调用该方法是必须处理抛出的异常；一般用try语句处理，你也可以继续抛出给下个调用者去处理；异常抛出的最终 点，在java虚拟机；建议对于异常的处理，尽量能处理就处理，不要在向上抛出。用try{}catch(){}处理。如：
        try
        {
               这里写调用有异常抛出的方法代码；
         }
         catch(AException e)//捕获抛出的异常AException
         {
               这里写异常捕获后的处理方式；
         }
         catch(BException e))//捕获抛出的异常BException
         {
               这里写异常捕获后的处理方式；
         }
         注意：当你调用的方法抛出多个异常时，而多个异常存在子父类关系，父类异常的捕获应当放在子类之后，否则编译失败；

        有了异常处理方法，这里就有了一种新的异常抛出方式，如下      
     B 用关键字 throw 在捕获到异常处理时，可以继续抛出异常
        当你在
        try
        { }
        catch(AException e )
        {
               你无法处理这个异常时，可以以继续向上抛出；
               throw new NewException( ) //这里通过 throw 关键字继续抛出一个新的异常，
         }

throws 关键字不可以在类的声明时使用，只能用于方法声明之后。

throw用在方法内抛出一个异常，throws用在方法声明出，表示该方法可能抛出一个或者多个异常

throws声明抛出异常只能在方法中的签名中使用，也就是说throws只能放在方法（函数）后，并写出异常类，表示抛出无法处理的异常

当方法无法处理抛出的异常的时候 我们可以通过throws把异常抛给方法的上一级调用者，如果上一级调用者还是无法处理，继续可以向上抛，知道抛给jvm处理，jvm的默认处理就是打印错误堆栈信息，
throw 只能放在方法中，用于抛出自定义异常

1. class ChuException extends RuntimeException
   
2. {
   
3.         ChuException(String r)//定义了一个除数异常
   
4.         {
   
5.         super(r);
   
6.         }
   
7. }
   
8. class BCException extends RuntimeException
   
9. {
   
10.         BCException(String r)//定义了一个被除数的异常
    
11.         {
    
12.         super(r);
    
13.         }
    
14. }
    
15. public class ExceptionDemo
    
16. {
    
17.         public static int div(int i,int j)<FONT color=darkgreen>throws BCException,ChuException//多个抛出类用都好隔开
    
18. </FONT>        {
    
19.                 if(j==0)
    
20.                        <FONT color=red> //当被被除数为0,就用throw抛出自定义的被除数异常
    
21. </FONT>                        throw new ChuException("除数不能为0");
    
22.                 if(i<0)
    
23.                         <FONT color=red>//当我们定义除数小于零的时候就抛出除数异常
    
24. </FONT>                    throw new BCException("被除数必须大于0");
    
25.                 return i/j;
    
26. 
    
27.         }
    
28.         public static void main(String[]agrs)//<FONT color=darkgreen>throws ChuException,BCexception(main不在方法中处理完就得抛
    
29. </FONT>        {
    
30.                 int m=-1;//m=1
    
31.                 int n=0;
    
32.                 try
    
33.                 {
    
34.                         int s=div(m,n<FONT color=red>);//在main方法中调用了div方法，也就是说main是div的上一级调用者
    
35.                 }                 //如果div抛出了异常，main要么的用try。。catch。。来处理，要么它没处理
    
36.                                   //就得在方法后抛出异常（上一级调用者是jvm）</FONT>
    
37.                 catch(BCException|ChuException e1)               
    
38.                 {
    
39.                         e1.printStackTrace();
    
40.                 }
    
41.                 <FONT color=red>//如果抛出的异常种类较多，catch就得捕获相应的异常  
    
42.                 //处理方式就是在catch中把多个异常类用”|"隔开
    
43. </FONT>                System.out.println("程序运行结束！！");
    
44.         }
    
45. }
    
46. //程序我们把m用了1和-1分别带入测试，n用0带入，结果发现如果m=-1，n=0，的时候只能抛出一个异常，因为程序
    
47. //只要抛出一个异常，程序立马暂时中断等待处理，处理完之后就跳回程序的下一步
    

复制代码

                        
throw和throws的区别：
1、throw代表动作，表示抛出一个异常的动作；throws代表一种状态，代表方法可能有异常抛出
2、throw用在方法实现中，而throws用在方法声明中
3、throw只能用于抛出一种异常，而throws可以抛出多个异常

1、throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。如下面例子所示：
public class Shoot {   创建类
static void pop() throws NegativeArraySizeException {
//定义方法并抛出NegativeArraySizeException异常
int [] arr = new int[-3];//创建数组
}
public static void main(String[] args) {//主方法
try {
pop(); //调用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法抛出的异常");//输出异常信息
}
}
}