创建java自定义异常类和使用throws和throw以及区别

throws是声明一个异常类，而throw是抛出一个异常对象，通常和自定义异常类一起用。现在来说如何创建java自定义异常类和使用throws和throw以及区别。

1.使用throws声明抛出异常类·
使用throws关键字的时候就是当前方法不知道如何处理这个异常或者只处理一些异常时，可以再把异常向上抛出，最后到main方法还不能解决时，再抛给虚拟机，这时候虚拟机就打印输出异常信息，终止程序的运行。

throws声明异常类只能在方法的后面，throws可以声明多个异常类，如:throws IoException,Exception…..

    

  1. public class Test{
    2. 

  2.      public void count()throws IOException{
    3. 

  3.         FileInputStream st=new FileInputStream("cccc.pdf");
    4. 

  4.     }
    5. 

  5.     public static void main (String arg[]){
    6. 

  6.         test tests=new test();
    7. 

  7.           try{
    8. 

  8.             tests.count();
    9. 

  9.         }catch(IOException ex){
    10. 

  10.             //......
    11. 

  11.         }
    12. 

  12.         System.out.println("执行到这里");
    13. 

  13.     }
    14. 

  14. }
    15.


上面的count方法不处理异常，直接抛给了mian方法，在main方法中捕获到了，就能接下去执行，这时候count方法不用try catch来捕获异常。如果main方法也不处理，直接给了虚拟机，则会终止执行。

    

  1. public class Test
    2. 

  2.       public void count()throws IOException{
    3. 

  3.         FileInputStream st=new FileInputStream("cccc.pdf");
    4. 

  4.     }
    5. 

  5.     public static void main (String arg[])throws IOException{
    6. 

  6.         Test tests=new Test();
    7. 

  7.         tests.count();
    8. 

  8.         System.out.println("执行到这里");
    9. 

  9.     }
    10. 

  10. }
    11.


注意:抛给上级的异常要是上传捕获异常的子类或者同类，也是就说，上级方法的声明的异常要是下级的父类或者同类。

使用throw抛出异常对象
throw是在方法体中用的，是抛出一个异常对象而不是一个异常类。

    

  1. public class Test
    2. 

  2.       public void count()throws IOException {
    3. 

  3.       try{
    4. 

  4.              FileInputStream st=new FileInputStream("cccc.pdf");
    5. 

  5.         }catch(IOException ex){
    6. 

  6.            throw new IOException("找不到类啊")
    7. 

  7.         }
    8. 

  8.     }
    9. 

  9.     public static void main (String arg[]){
    10. 

  10.        try{
    11. 

  11.             tests.count();
    12. 

  12.         }catch(IOException ex){
    13. 

  13.              ex.printStackTrace();
    14. 

  14.         }
    15. 

  15.         System.out.println("执行到这里");
    16. 

  16.     }
    17. 

  17. }
    18.

虽然说不用抛出异常程序也能主动的抛给上次，处理结果也一样，但是这样带给我们了机动性，我们可以抛出我们自定义的异常类。

Java自定义异常Exception
我们自定义异常类通常是继承Exception类，如何要自定义Runtime异常类，我们可以继承RuntimeException类。自定义异常类要提供一个无参构造和有一个字符串的参数的构造器，用来描述该异常的错误信息，也是 ex.printStackTrace()输出值或者 ex.getMessage()返回值。

    

  1. public class ZhidingException extends Exception {
    2. 

  2.     public  ZhidingException(){ }
    3. 

  3.      public ZhidingException(String msg){
    4. 

  4.                 super(msg);
    5. 

  5.             }
    6. 

  6. }
    7.

就这样我们就创建了一个异常类，这个异常类至少要这2个方法，第2个方法也简单，只要super()就能传输异常描述了，自定义Runtime异常类也一样，只是把Exception改成RuntimeException就行，于是我们可以用throw抛出来了

    

  1. public class Test
    2. 

  2.       public void count()throws ZhidingException {
    3. 

  3.       try{
    4. 

  4.              FileInputStream st=new FileInputStream("cccc.pdf");
    5. 

  5.         }catch(ZhidingException ex){
    6. 

  6.            throw new ZhidingException("找不到类啊")
    7. 

  7.        }
    8. 

  8.     }
    9. 

  9.     public static void main (String arg[]){
    10. 

  10.        try{
    11. 

  11.             tests.count();
    12. 

  12.         }catch(ZhidingException ex){
    13. 

  13.              ex.printStackTrace();
    14. 

  14.         }
    15. 

  15.         System.out.println("执行到这里");
    16. 

  16.     }
    17. 

  17. }
    18.

总结:
throw用于抛出一个异常类对象，通常用于自定义的异常类情况，而throws用在方法声明中告诉调用者该方法会抛出什么类型的异常，而异常的捕获由调用该方法的人去捕获。

原创来源：滴一盘技术