请问throw和throws的区别是什么？什么时候用它们，举例说明。

throw定义在函数内，用于抛出异常对象
throws定义在函数上，用于抛出异常类，可抛出多个,异常类之间用逗号

1. class MyException extends Exception
   
2. {
   
3. 
   
4. }
   
5. class Demo
   
6. {
   
7.          // 假如此函数运行时有异常
   
8.          public void method()throws MyException//throws 用在函数上抛出的是类MyException
   
9.          {
   
10.                 throw new MyException();//throw用在method函数内，抛出的是对象new MyException()。
    
11.          }
    
12. }

复制代码

throws是用来声明一个方法可能抛出的所有异常信息
throw则是指抛出的一个具体的异常类型。
通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个具体的异常信息。
throws通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；
throw则需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。

public ArrayList getList() throws Exception //throws是用来声明抛出什么异常的
    {
        try
        {
            ArrayList result = new ArrayList();
            return result;
        } catch (Exception e)
        {
            throw new Exception(e); //throw是用来抛出异常的
        }
    }
throws是声明，throw 是动作

Throwable：可抛出的。
        |--Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。
        |--Exception：异常，可以有针对性的处理方式

无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名才作为子类的后缀名。

这个体系中的所有类和对象都具备一个独有的特点；就是可抛性。

可抛性的体现：就是这个体系中的类活对象都可以分别被throws或throw两个关键字所操作。

throw和throws的用法区别：
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个异常类用逗号隔开。
throw和throws用法示例，用于自定义异常；
需求：在本程序中，对于除数是负数，也视为是错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述（描述出错信息和给出出错的数值）。

1. class FuShuException extends Exception
   
2. {
   
3.         private int value;        //记录出错的值
   
4.         FuShuException(String msg,int value)      //自定义异常信息
   
5.         {
   
6.                 super(msg);      //继承父类的构造函数，重写
   
7.                 this.value = value;
   
8.         }
   
9.         public int getValue()
   
10.         {
    
11.                 return this.value;
    
12.         }
    
13. }
    
14. class Demo
    
15. {
    
16.         int div(int a , int b)throws FuShuException   //FuShuException继承于Exception类，必须显式抛出给调用该方法的函数，这里是主函数
    
17.         {
    
18.                 if(b < 0)
    
19.                         throw new FuShuException("出现了除数是负数的情况.../by fushu",b);  //手动通过throw关键字抛出一个自定义异常对象
    
20.                 return a/b;
    
21.         }
    
22. }
    
23. class ExceptionDemo2
    
24. {
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 Demo d = new Demo();
    
28. //捕获并处理异常
    
29.                 try
    
30.                 {
    
31.                         int x = d.div(4,-1);
    
32.                     System.out.println("x="+x);
    
33.                 }
    
34.                 catch (FuShuException e)
    
35.                 {
    
36.                         System.out.println(e.toString());
    
37.                         System.out.println("出错的除数值是："+e.getValue());
    
38.                 }
    
39.                 System.out.println("over!");
    
40.         }
    
41. }

复制代码

请看毕老师的第9天和第10天的视频，讲的很明白

throws:用来声明一个方法可能抛出的所有异常，使用在函数上，后面跟的是异常类，可以有多个，用逗号隔开；
throw:抛出的是一个具体的类型；使用在函数内，后面跟的是异常对象；
class Demo1{
        public static void show()throws ArrayIndexOutOfBoundsException{//抛出一个一个异常类。
                try{
                        int[] arr = {2,4,6,1,3,5,9,8};
                        System.out.println(arr[10]);
                }catch(Exception e){
                        throw new RuntimeException("数组角标越界");//抛出的一个异常对象。
                }
        }
        public static void main(String[] args) {               
                show();
        }
}

throw语句用来明确地抛出一个 “异常”。（定义在函数内，用于抛出异常对象。）
throws用来标明一个成员函数可能抛出的各种“异常”。（定义在函数上，用于抛出异常类，可以抛出多个异常类用逗号隔开。）