Java学习之异常处理

在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出），Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
       Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

Exception（异常）:是程序本身可以处理的异常。

Exception 类有一个重要的子类 RuntimeException，RuntimeException 类及其子类表示“JVM 常用操作”引发的错误，例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

通常，Java的异常(包括Exception和Error)分为检测异常（checked exceptions）和非检测异常（unchecked exceptions）。
      检测异常（编译器要求必须处置的异常）：正确的程序在运行中，很容易出现的、情理可容的异常状况。检测异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常，这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现检测异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

非检测异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。

Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
    非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常

其实异常的应用情景可以概括为以下：

一、调用代码不能继续执行，需要立即终止。出现这种情况的可能性太多太多，例如服务器连接不上、参数不正确等。这些时候都适用非检测异常，不需要调用代码的显式捕捉和处理，而且代码简洁明了。

二、调用代码需要进一步处理和恢复。假如将 SQLException 定义为非检测异常，这样操作数据时开发人员理所当然的认为 SQLException 不需要调用代码的显式捕捉和处理，进而会导致严重的 Connection 不关闭、Transaction 不回滚、DB 中出现脏数据等情况，正因为 SQLException 定义为检测异常，才会驱使开发人员去显式捕捉，并且在代码产生异常后清理资源。当然清理资源后，可以继续抛出非检测异常，阻止程序的执行。根据观察和理解，检测异常大多可以应用于工具类中。

*异常的注意事项：
1，子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
2，如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。 
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try .

*异常处理的原则：
1，函数内容如果抛出需要检测的异常，那么函数上必须要声明。
　　否则必须在函数内用try...catch捕捉，否则编译失败。
2，如果调用声明有异常的函数，要么try...catch要么throws，否则编译失败。

3，什么时候catch，什么时候throws 呢？
　　可以解决的异常，用catch。
　　解决不了，用throws告诉调用者，由调用者解决 。

4，一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。
内部中有几个需要检测的异常，就抛几个异常。

*异常的分类：
1，编译时被检测异常（编译异常）:除了特殊子类RuntimeException体系，Exception和其子类都是编译时异常，这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式，这样的问题都可以针对性的处理。

2，编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类，这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止,让调用者对代码进行修正。所以自定义异常时，要么继承Exception。要么继承RuntimeException。典型的RuntimeException包括NullPointerException、IndexOutOfBoundsException、IllegalArgumentException等。典型的非RuntimeException（编译异常）包括IOException、SQLException等。

3、try、catch、finally语句块的执行顺序:

1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；

2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；

3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

 图2  图示try、catch、finally语句块的执行

*throws 和throw的区别

1，throws使用在函数上
　　throw使用在函数内
2，throws抛出的是异常类，可以抛出多个，用逗号隔开。
　　throw抛出的是异常对象。

*抛出异常

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

1）throws抛出异常

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

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

 methodname throws Exception1,Exception2,..,ExceptionN
 {
 }  

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

 import java.lang.Exception;
 public class TestException {
     static void pop() throws NegativeArraySizeException {
         // 定义方法并抛出NegativeArraySizeException异常
         int[] arr = new int[-]; // 创建数组
     }  
 
     public static void main(String[] args) { // 主方法
         try { // try语句处理异常信息
             pop(); // 调用pop()方法
         } catch (NegativeArraySizeException e) {
             System.out.println("pop()方法抛出的异常");// 输出异常信息
         }
     }  
 
 }  

使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。pop方法没有处理异常NegativeArraySizeException，而是由main函数来处理。

Throws抛出异常的规则：

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

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

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

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

 void method1() throws IOException{}  //合法    
 
 //编译错误，必须捕获或声明抛出IOException
 void method2(){
   method1();
 }    
 
 //合法，声明抛出IOException
 void method3()throws IOException {
   method1();
 }    
 
 //合法，声明抛出Exception，IOException是Exception的子类
 void method4()throws Exception {
   method1();
 }    
 
 //合法，捕获IOException
 void method5(){
  try{
     method1();
  }catch(IOException e){…}
 }    
 
 //编译错误，必须捕获或声明抛出Exception
 void method6(){
   try{
     method1();
   }catch(IOException e){throw new Exception();}
 }    
 
 //合法，声明抛出Exception
 void method7()throws Exception{
  try{
   method1();
  }catch(IOException e){throw new Exception();}
 }   

 

判断一个方法可能会出现异常的依据如下：
     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，则该方法的调用者可选择处理该异常。

3、常见异常

在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:

1. runtimeException子类:

    1、 java.lang.ArrayIndexOutOfBoundsException
    数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
    2、java.lang.ArithmeticException
    算术条件异常。譬如：整数除零等。
    3、java.lang.NullPointerException
    空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
    4、java.lang.ClassNotFoundException
    找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

5、java.lang.NegativeArraySizeException  数组长度为负异常

6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

7、java.lang.SecurityException 安全性异常

8、java.lang.IllegalArgumentException 非法参数异常

2.IOException

IOException：操作输入流和输出流时可能出现的异常。

EOFException   文件已结束异常

FileNotFoundException   文件未找到异常

3. 其他

ClassCastException    类型转换异常类

ArrayStoreException  数组中包含不兼容的值抛出的异常

SQLException   操作数据库异常类

NoSuchFieldException   字段未找到异常

NoSuchMethodException   方法未找到抛出的异常

NumberFormatException    字符串转换为数字抛出的异常

StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

IllegalAccessException  不允许访问某类异常

InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常

 class BlueException extends Exception{
     public BlueException(String message){
         System.out.println(message);
     }
 }
 
 class BreakException extends Exception{
     public BreakException(String message){
         System.out.println(message);
     }
 }
 
 class HanderException extends Exception{
     public HanderException(String message){
         System.out.println(message);
     }
 }
 
 class Computer{
     private int status;
     public void work(int status,String name) throws BreakException, BlueException{
         if(status==1){
             throw new BlueException("电脑蓝屏了，请重启");
         }else if(status==2){
             throw new BreakException("电脑彻底,请给客服打电话……");
         }else{
             System.out.println("正常上课，老师姓名为："+name);
         }
     }
     public void reset(){
         System.out.println("Computer reset success......");
     }
 }
 /**
  * 编译时候异常必须处理，运行时候异常可处理也可不处理
  * @author sunfei
  *
  */
 class Teacher{
     private String username;
     private Computer computer;
     public Teacher(String useranme,Computer computer){
         this.username=useranme;
         this.computer=computer;
     }
     public void teacher(int status) throws HanderException{
         try {
             this.computer.work(status, this.username);
             this.computer.reset();
         } catch (BreakException e) {
             System.out.println(e.toString());
             this.replace();
             throw new HanderException("客服正在赶来……");
         } catch (BlueException e) {
             System.out.println(e.toString());
             go();
         }
     }
 
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public Computer getComputer() {
         return computer;
     }
     public void setComputer(Computer computer) {
         this.computer = computer;
     }
     public void go(){
         System.out.println("重启之后继续……");
     }
     public void replace(){
         System.out.println("换人之后继续……");
     }
 }
 
 public class Example2 {
     public static void main(String[] args) throws HanderException {
         Computer computer = new Computer();
         Teacher t = new Teacher("张三",computer);
         Scanner scanner = new Scanner(System.in);
         System.out.println("请输入状态");
         int status = scanner.nextInt();
         System.out.println(t.getUsername());
         while(status!=0){
             t.teacher(status);
             status=scanner.nextInt();
         }
     }
 }

3. 常见异常