在异常中有个throws意思是抛出异常，在自定义异常中又出现个throw，也是抛出异常，有什么区别吗？

Throws在方法签名中使用，用于声明该方法可能抛出的异常。
Throw在函数内使用，用于抛出一个实际的异常。

throws关键字通常应用在方法上，用来指定可能跑出的异常，多个异常要用逗号隔开，当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象

1. class Demo
   
2. {
   
3.         int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException<FONT color=red>//在功能上通过throws的关键字声明了该功能有可能会出现问题</FONT>。
   
4.         {
   
5. 
   
6.                 int[] arr = new int[a];
   
7. 
   
8.                 System.out.println(arr[4]);
   
9. 
   
10.                 return a/b;
    
11.         }
    
12. }
    
13. 
    
14. 
    
15. class  ExceptionDemo2
    
16. {
    
17.         public static void main(String[] args) //throws Exception
    
18.         {
    
19.                 Demo d = new Demo();
    
20.                 try
    
21.                 {
    
22.                         int x = d.div(5,0);
    
23.                         System.out.println("x="+x);
    
24.                 }
    
25.                
    
26.                 catch (ArithmeticException e)
    
27.                 {
    
28.                         System.out.println(e.toString());
    
29.                         System.out.println("被零除了!!");
    
30. 
    
31.                 }
    
32.                 catch (ArrayIndexOutOfBoundsException e)
    
33.                 {
    
34.                         System.out.println(e.toString());
    
35.                         System.out.println("角标越界啦！！");
    
36.                 }
    
37.                 System.out.println("over");
    
38.         }
    
39. }

复制代码

throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要跑出的异常；如果要捕捉throw抛出的异常，则必须使用try—catch语句。

1. class FuShuException extends Exception
   
2. {
   
3.         private int value;
   
4. 
   
5.         FuShuException()
   
6.         {
   
7.                 super();
   
8.         }
   
9.         FuShuException(String msg,int value)
   
10.         {
    
11.                 super(msg);
    
12.                 this.value = value;
    
13.         }
    
14. 
    
15.         public int getValue()
    
16.         {
    
17.                 return value;
    
18.         }
    
19. 
    
20. }
    
21. class Demo
    
22. {
    
23.         int div(int a,int b)throws FuShuException
    
24.         {
    
25.                 if(b<0)
    
26.                         throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//<FONT color=red>手动通过throw关键字抛出一个自定义异常对象。
    
27. </FONT>
    
28.                 return a/b;
    
29.         }
    
30. }
    
31. 
    
32. 
    
33. class  ExceptionDemo3
    
34. {
    
35.         public static void main(String[] args)
    
36.         {
    
37.                 Demo d = new Demo();
    
38.                 try
    
39.                 {
    
40.                         int x = d.div(4,-9);
    
41.                         System.out.println("x="+x);               
    
42.                 }
    
43.                 catch (FuShuException e)
    
44.                 {
    
45.                         System.out.println(e.toString());
    
46. 
    
47.                         System.out.println("错误的负数是："+e.getValue());
    
48.                 }
    
49.                 System.out.println("over");
    
50. 
    
51.         }
    
52. }

复制代码