Java 异常

前两天头条面试官问我:你说你java 比较熟，那你跟我说说Exception继承哪个类。

我告诉继承的是Object 类。

一：异常的种类

  1.java.lang.throwable 类可以分为Error 和Exception类。 

  Error 是指系统崩溃出现的错误，主要是有OutOfMemoryError 

 Exception 是指程序中的异常。这两者的最大区别是程序本身是否能处理！ Error 程序是处理不了的，是系统出现的错误。而Exception是程序内部可以解决的问题。

 2.Exception 分为可以检查的的异常和不可检查的异常。

  （Checked Excetion）:是指在你写代码的时候，系统会提示你你要处理你代码里编译器检查到的异常，不然就通不过编译。 比如你写个File file = new File(" ..");系统会要求你处理FileNotFoundException.再如 UrlEncoder 会要求处理  UnSupportedException .

  (RuntimeException)是指编译器检查不出来的异常（包含Error），只有在运行时才知道会不会出现异常。RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等。你写 int a=b/c; 编译器不会要求你要catch异常。 当运行时 输入c=0时，系统会报告你出现了异常ArithmeticException。  对于RuntimeException来说 一般不进行try-catch ，当然也可以直接对其进行处理。 

二：异常的处理

  包括抛出异常和捕获异常。

         抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

        捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

    上边就指出异常链，我本身这个方法抛出异常，但我却没处理，运行时系统会从我的调用者里找处理这个异常的方法，找不到，系统终止。

try {    lowLevelOp();   } catch (LowLevelException le) {     throw (HighLevelException)     new HighLevelException().initCause(le);   }  

    当程序捕获到了一个底层异常le，在处理部分选择了继续抛出一个更高级别的新异常给此方法的调用者。 
    这样异常的原因就会逐层传递。这样，位于高层的异常递归调用getCause()方法，就可以遍历各层的异常原因。 
    这就是Java异常链的原理。异常链的实际应用很少，发生异常时候逐层上抛不是个好注意， 
    上层拿到这些异常又能奈之何？而且异常逐层上抛会消耗大量资源， 
    因为要保存一个完整的异常链信息. 

   异常能处理就处理，不能处理就抛出，最终没有处理的异常JVM会进行处理，不能处理就报错。（所以出错时，会打印出各种调用方法栈，是因为异常链的原因。）

    

抛出异常

      任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。

1. throws抛出异常

   如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。

     throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为：

1. methodname throws Exception1,Exception2,..,ExceptionN  
2. {  
3. }  

    方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。例如：

1. import java.lang.Exception;  
2. public class TestException {  
3.     static void pop() throws NegativeArraySizeException {  
4.         // 定义方法并抛出NegativeArraySizeException异常  
5.         int[] arr = new int[-3]; // 创建数组  
6.     }  
7.   
8.     public static void main(String[] args) { // 主方法  
9.         try { // try语句处理异常信息  
10.             pop(); // 调用pop()方法  
11.         } catch (NegativeArraySizeException e) {  
12.             System.out.println("pop()方法抛出的异常");// 输出异常信息  
13.         }  
14.     }  
15.   
16. }  

    使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。

    pop方法没有处理异常NegativeArraySizeException，而是由main函数来处理。

    Throws抛出异常的规则：

    1) 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

    2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

    3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

    4）调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

    例如：

1. void method1() throws IOException{}  //合法    
2.    
3. //编译错误，必须捕获或声明抛出IOException    
4. void method2(){    
5.   method1();    
6. }    
7.    
8. //合法，声明抛出IOException    
9. void method3()throws IOException {    
10.   method1();    
11. }    
12.    
13. //合法，声明抛出Exception，IOException是Exception的子类    
14. void method4()throws Exception {    
15.   method1();    
16. }    
17.    
18. //合法，捕获IOException    
19. void method5(){    
20.  try{    
21.     method1();    
22.  }catch(IOException e){…}    
23. }    
24.    
25. //编译错误，必须捕获或声明抛出Exception    
26. //throw 的时候必须 throws ~~~~
27. void method6(){    
28.   try{    
29.     method1();    
30.   }catch(IOException e){throw new Exception();}    
31. }    
32.    
33. //合法，声明抛出Exception    
34. void method7()throws Exception{    
35.  try{    
36.   method1();    
37.  }catch(IOException e){throw new Exception();}    
38. }   

     判断一个方法可能会出现异常的依据如下：
     1）方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。
     2）调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1()方法，method1()方法声明抛出IOException，因此，在method3()方法中可能会出现IOException。

2. 使用throw抛出异常

　  throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
　　我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为：
    throw new exceptionname;
    例如抛出一个IOException类的异常对象：
    throw new IOException;
    要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的：
    throw new String("exception");

    这是因为String 不是Throwable 类的子类。

     如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

       如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。

1. package Test;  
2. import java.lang.Exception;  
3. public class TestException {  
4.     static int quotient(int x, int y) throws MyException { // 定义方法抛出异常  
5.         if (y < 0) { // 判断参数是否小于0  
6.             throw new MyException("除数不能是负数"); // 异常信息  
7.         }  
8.         return x/y; // 返回值  
9.     }  
10.     public static void main(String args[]) { // 主方法  
11.         int  a =3;  
12.         int  b =0;   
13.         try { // try语句包含可能发生异常的语句  
14.             int result = quotient(a, b); // 调用方法quotient()  
15.         } catch (MyException e) { // 处理自定义异常  
16.             System.out.println(e.getMessage()); // 输出异常信息  
17.         } catch (ArithmeticException e) { // 处理ArithmeticException异常  
18.             System.out.println("除数不能为0"); // 输出提示信息  
19.         } catch (Exception e) { // 处理其他异常  
20.             System.out.println("程序发生了其他的异常"); // 输出提示信息  
21.         }  
22.     }  
23.   
24. }  
25. class MyException extends Exception { // 创建自定义异常类  
26.     String message; // 定义String类型变量  
27.     public MyException(String ErrorMessagr) { // 父类方法  
28.         message = ErrorMessagr;  
29.     }  
30.   
31.     public String getMessage() { // 覆盖getMessage()方法  
32.         return message;  
33.     }  
34. }  

4.3 异常链

      1) 如果调用quotient(3,-1)，将发生MyException异常，程序调转到catch (MyException e)代码块中执行；

      2) 如果调用quotient(5,0)，将会因“除数为0”错误引发ArithmeticException异常，属于运行时异常类，由Java运行时系统自动抛出。quotient（）方法没有捕捉ArithmeticException异常，Java运行时系统将沿方法调用栈查到main方法，将抛出的异常上传至quotient（）方法的调用者：

         int result = quotient(a, b); // 调用方法quotient()
        由于该语句在try监控区域内，因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出，并匹配catch子句：

       catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} 

        处理结果是输出“除数不能为0”。Java这种向上传递异常信息的处理机制，形成异常链。

       Java方法抛出的可查异常将依据调用栈、沿着方法调用的层次结构一直传递到具备处理能力的调用方法，最高层次到main方法为止。如果异常传递到main方法，而main不具备处理能力，也没有通过throws声明抛出该异常，将可能出现编译错误。

      3)如还有其他异常发生，将使用catch (Exception e)捕捉异常。由于Exception是所有异常类的父类，如果将catch (Exception e)代码块放在其他两个代码块的前面，后面的代码块将永远得不到执行，就没有什么意义了，所以catch语句的顺序不可掉换。

4.4 Throwable类中的常用方法

注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

     getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。

　 getMeage()：返回异常的消息信息。

　 printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。

     有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。

总结： 就是  出现异常你处理不处理，不处理我就抛给调用者（throws）, 处理就catch ，抛抛抛 catch catch catch.