哪位好心的学长 帮忙回答下 throw和throws的区别在那里呢 一直搞不明白 请大神指点

1）用throws声明的异常表示此方法不处理异常，而交给方法的调用处处理。
比如：

1. class Math{
   
2. public int div(int i,int j) throws Exception{  //方法可以不处理异常
   
3. int temp=i/j;
   
4. return temp;
   
5.         }
   
6. }
   
7. 
   
8. public class ThrowsDemo
   
9. {
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 Math m=new Math();
    
13.                 try{
    
14.                         System.out.println("除法操作："+m.div(10,2));   //可以看出，在主方法中添加了try...catch，异常交由主程序处理
    
15.                 }catch(Exception e)
    
16.                 {e.printStacktrace();
    
17.                 }
    
18.                         }
    
19. }
    

复制代码

而可以使用throw直接抛出一个异常，

1. class Math{
   
2. public int div(int i,int j) throws Exception{  //方法可以不处理异常
   
3. int temp=0;
   
4. try{
   
5. temp=i/j;                                      //如果产生异常，教给catch
   
6. 
   
7. }catch(Exception e){                           //捕获异常
   
8. throw e;
   
9. }finally{
   
10. System.out.println("****** div over******")
    
11. 
    
12. }
    
13. return temp;
    
14.         }
    
15. }
    
16. 
    
17. public class ThrowsDemo
    
18. {
    
19.         public static void main(String[] args)
    
20.         {
    
21.                 Math m=new Math();
    
22.                 try{
    
23.                         System.out.println("除法操作："+m.div(10,2));
    
24.                 }catch(Exception e)
    
25.                 {e.printStacktrace();
    
26.                 }
    
27.                         }
    
28. }
    

复制代码

throw抛出异常，throws声明方法抛出异常。

throws是声明异常，写在方法后面
throw是抛出异常，写在代码里

  public Test() throws RepletException {
    try {
      System.out.println("Test this Project!")
    }
    catch (Exception e) {
      throw new Exception(e.toString());
    }
  }

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

Throws 用在函数上，后面跟异常类，可以跟多个，用逗号隔开。
作用是给这个函数声明一个异常，提醒调用者这个函数运行时可能会有异常出现，在使用时需要处理
Throw用在函数内，后面跟异常对象。
作用是当出现一个情况后，编程人员可以把这个情况当作异常，将其抛出。

1. class Demo
   
2. {
   
3.         int div(int a,int b) throws FuShuException
   
4.         {
   
5.                 if(b<0)
   
6.                         throw new FuShuException("除数中出现了负数！！！");//手动通过throw抛出一个自定义异常类对象
   
7.                 return a/b;
   
8.         }
   
9. }
   

复制代码