Java之异常处理具体使用总结

导读：

1、异常的分类；

2、Java的异常处理机制：

 2.1、异常try catch finally；

 2.2、异常声明：throws；

 2.3、人工抛出异常；

3、异常处理原则；

4、自定义异常；

5、throw和throws的区别。

1、异常的分类：

  Java中的Throwable类时所有异常类的父类。

（1）Error：通常是指出现重大问题，如JVM系统内部错误、资源耗尽等；

            不编写针对代码进行处理。

（2）Exception：在运行过程中出现的一些情况，如等；

                通常使用try catch finally处理。

   a、编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException和其子类。

                      这种问题一旦出现，在编译时就检测，让这种问题有对应的处理方式。

   b、编译时不检测异常(运行时异常)：就是Exception中的 RuntimeException和其子类。                 

                      这种问题的发生，会使程序无法进行，大多是因为调用者的原因导致或者引发了内部状态的改变而导致。

                      那么这种问题一般不处理，直接编译通过在运行时让调用者的程序强制停止 ,让调用者对代码进行修正。

所以自定义异常时要么继承 ExceptiExcepti，要么继承RuntimeException。

2、Java的异常处理机制：

 2.1、异常try catch finally

   (1)try后可跟一个或多个catch语句块；

   (2)finally是可选的，一旦有finally，不论try代码块是否出现异常事件都会被执行。

public class Test2(){
  public static void main (String[] args){
    String aa[] = {"cat","dog","bird"};
    try{
      for(int i=0;i<5;i++){
        System.out.println(aa.[i]);
      }
    }catch(ArrayIndexOutOfBoundsException e){
      System.out.println("exception");
    }finally{
      System.out.println("finally");
    }
    System.out.println("end");
  }
}

程序运行输出结果为：

cat
dog
bird
exception
finally

 2.2、异常声明：throws

  在重写方法中声明抛出的异常不允许抛出比重写方法范围更大的异常类型。

public class TestThrowsException{
  public static void main(String[] args){
    TestThrowsException t = new TestThrowsException();
    try{
      t.readFile();
    }catch(IOException e){
      System.out.println(e);
    }
  }
  public void readFile()throws IOException{
    FileInputStream in = new FileInputStream("aa.txt");
    int b;
    b = in.read();
    while(b != 1){
      System.out.println((char)b);
      b = in.read();
    }
    in.close();
  }
}

异常被提交给调用者，如果仍找不到处理代码，程序会出错退出。因此除非事先约定，否则在开发过程中不能在自己编写的方法中使用此类异常处理方式。

 2.3、人工抛出异常

  需要人工创建一个异常类，然后通过throw 语句实现抛出操作。

  import java.util.Scanner;
  public class TestThrowException{
    public static void main(String[] args){
      TestThrowException t = new TestThrowException();
      System.out.println("请输入一个偶数：");
      System.out.println("输入的偶数是："+t.inputNum());
    }
    public int inputNum(){
      int res = -1;
      Scanner scan = new Scanner(System.in);
      while(true){
        try{
          res = scan.nextInt();
          if(res<0 || (res%2!=0)){
            Exception e = new Exception("输入的不是偶数！");
            throw e;
          }
          break;
        }catch(Exception e){
          System.out.println(e.getMessage()+"请重新输入：");
          continue;
        }
      }
      return res;
    }
  }

程序运行输出结果：

请输入一个偶数：5

输入的不是偶数！请重新输入：-1

输入的不是偶数！请重新输入：2

输入的偶数是：2

注：一般并不使用异常处理机制来检查数据取值范围，可通过if-else语句来做检查。

3、异常处理原则：

（1）、方法内如果抛出需要检测的异常，那么方法上必须要声明。

       否则必须在方法内用try catch捕捉，否则编译失败。

（2）、如果调用到了声明异常的方法，要么try catch要么throws，否则编译失败。

（3）、何时catch？何时throws？

       方法内可以解决处理掉的，用catch；

       解决不了的，用throws 告诉调用者，由调用者解决。

（4）、一个功能如果抛出了多个异常，那么调用时，必须有多个catch对应的处理。

       内部有几个需要检测的异常，就抛出几个异常，抛出几个异常，就用几个catch。

注意：

（1）子类在重写父类的方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类异常或者父类异常类的子类。

（2）如果父类抛出了多个异常，那么子类只能抛出父类异常的子集。

          如果父类的方法中没有抛出异常，那么子类重写时绝对不能抛出异常，只能try catch。

4、自定义异常：                

    自定义异常时，必须继承Exception或者RuntimeException。

5、throw和throws的区别：

（1）throws使用在方法上。

     throw使用在方法内。

（2）throws抛出的是异常类，可以抛出多个，用逗号隔开。

     throw抛出的是异常对象。