二：Java之异常处理

浏览数：21 / 时间：2015年06月08日

一、异常的概念

异常，也就是非正常情况。事实上，异常本质上是程序上的错误，包括程序逻辑错误和系统错误。错误在我们编写程序的过程中会经常发生，包括编译期间和运行期间的错误，在编译期间出现的错误有编译器帮助我们一起修正，然而运行期间的错误便不是编译器力所能及了。假若程序在运行期间出现了错误，如果置之不理，程序便会终止或直接导致系统崩溃，显然这不是我们希望看到的结果。因此，如何对运行期间出现的错误进行处理和补救呢？Java提供了异常机制来进行处理，通过异常机制来处理程序运行期间出现的错误。通过异常机制，我们可以更好地提升程序的健壮性。

二、了解Java异常分类

在Java中异常被当做对象来处理，根类是java.lang.Throwable类，在Java中定义了很多异常类（如OutOfMemoryError、NullPointerException、IndexOutOfBoundsException等），这些异常类分为两大类：Error和Exception。

Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

　　Error是无法处理的异常，比如OutOfMemoryError，一般发生这种异常，JVM会选择终止程序。表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止

　　Exception，也就是我们经常见到的一些异常情况，比如NullPointerException、IndexOutOfBoundsException，是程序本身可以处理的异常。 Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和ArrayIndexOutOfBoundException。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

Exception类的异常包括checkedexception和unchecked exception（uncheckedexception也称运行时异常RuntimeException，当然这里的运行时异常并不是前面我所说的运行期间的异常，只是Java中用运行时异常这个术语来表示，Exception类的异常都是在运行期间发生的）。

可查异常（编译器要求必须处置的异常）：正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

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

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

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

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

三、处理异常机制

第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。

<span style="font-size:18px;"><span style="font-size:18px;">
1. boolean testEx2() throws Exception{  
2.         boolean ret = true;  
3.         int b=12;  
4.         int c;  
5.         for (int i=2;i>=-2;i--){  
6.             c=b/i;  
7.             System.out.println("i="+i);  
8.         }  
9.         return true;      
10.}</span></span>

第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。

<span style="font-size:18px;"><span style="font-size:18px;">1. boolean testEx2() throws Exception{  
2.         boolean ret = true;  
3.         try{  
4.             int b=12;  
5.             int c;  
6.             for (int i=2;i>=-2;i--){  
7.                 c=b/i;  
8.                 System.out.println("i="+i);  
9.             }  
10.            return true;  
11.        }catch (Exception e){  
12.            System.out.println("testEx2, catch exception");  
13.            Throw e;  
14.        }  
15.    }</span></span>

第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。

<span style="font-size:18px;"><span style="font-size:18px;">1.  boolean testEx2() throws Exception{  
2.         boolean ret = true;  
3.         try{  
4.             int b=12;  
5.             int c;  
6.             for (int i=2;i>=-2;i--){  
7.                 c=b/i;  
8.                 System.out.println("i="+i);  
9.                 throw new Exception("aaa");  
10.            }  
11.            return true;  
12.        }catch (java.lang.ArithmeticException e){  
13.            System.out.println("testEx2, catch exception");  
14.            ret = false;  
15.            throw new Exception("aaa");  
16.        }finally{  
17.            System.out.println("testEx2, finally; return value="+ret);  
18.        }  
19.}</span></span>

四、异常捕获及处理：

在Java中如果需要处理异常，必须先对异常进行捕获，然后再对异常情况进行处理。如何对可能发生异常的代码进行异常捕获和处理呢？使用try和catch关键字即可，如下面一段代码所示：

<span style="font-size:18px;">try {
  File file = new File("d:/a.txt");
  if(!file.exists())
    file.createNewFile();
}catch (IOException e) {
  // TODO: handle exception
}</span>

　　被try块包围的代码说明这段代码可能会发生异常，一旦发生异常，异常便会被catch捕获到，然后需要在catch块中进行异常处理。

　　这是一种处理异常的方式。在Java中还提供了另一种异常处理方式即抛出异常，顾名思义，也就是说一旦发生异常，我把这个异常抛出去，让调用者去进行处理，自己不进行具体的处理，此时需要用到throw和throws关键字。　

　　下面看一个示例：

public class Main {
    public static void main(String[] args) {
        try {
            createFile();
        }catch (Exception e) {
            // TODO: handle exception
        }
    }
     
    public static void createFile()throws IOException{
        File file = new File("d:/a.txt");
        if(!file.exists())
            file.createNewFile();
    }
}

　　这段代码和上面一段代码的区别是，在实际的createFile方法中并没有捕获异常，而是用throws关键字声明抛出异常，即告知这个方法的调用者此方法可能会抛出IOException。那么在main方法中调用createFile方法的时候，采用try...catch块进行了异常捕获处理。

　　当然还可以采用throw关键字手动来抛出异常对象。下面看一个例子：

<span style="font-size:18px;">public class Main {
    public static void main(String[] args) {
        try {
            int[] data = new int[]{1,2,3};
            System.out.println(getDataByIndex(-1,data));
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }
         
    }
     
    public static int getDataByIndex(int index,int[] data) {
        if(index<0||index>=data.length)
            throw new ArrayIndexOutOfBoundsException("数组下标越界");
        return data[index];
    }
}</span>

　　然后在catch块中进行捕获。

　　也就说在Java中进行异常处理的话，对于可能会发生异常的代码，可以选择三种方法来进行异常处理：

　　1）对代码块用try..catch进行异常捕获处理；

　　2）在该代码的方法体外用throws进行抛出声明，告知此方法的调用者这段代码可能会出现这些异常，你需要谨慎处理。此时有两种情况：

　　　　如果声明抛出的异常是非运行时异常，此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。

　　　　如果声明抛出的异常是运行时异常，此方法的调用者可以选择地进行异常捕获处理。

　　3）在代码块用throw手动抛出一个异常对象，此时也有两种情况，跟2）中的类似：

　　　　如果抛出的异常对象是非运行时异常，此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。

throws和thow关键字

　　1）throws出现在方法的声明中，表示该方法可能会抛出的异常，然后交给上层调用它的方法程序处理，允许throws后面跟着多个异常类型；

　　2）一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。throw只会出现在方法体中，当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw出去。throw关键字的一个非常重要的作用就是异常类型的转换（会在后面阐述道）。

　　throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由方法去处理异常，真正的处理异常由此方法的上层调用处理。

五、异常的使用

1、使用已有的异常类，假如为IOException、SQLException。

try{
  程序代码
}catch(IOException ioe){
  程序代码
}catch(SQLException sqle){
  程序代码
}finally{
  程序代码
}

2、自定义异常类
创建Exception或者RuntimeException的子类即可得到一个自定义的异常类。例如:

<span style="font-size:18px;">public class MyException extends Exception{
  public MyException(){}
  public MyException(String smg){
   super(smg);
  }
 }</span>

3、使用自定义的异常
用throws声明方法可能抛出自定义的异常，并用throw语句在适当的地方抛出自定义的异常。例如：

在某种条件抛出异常

<span style="font-size:18px;">public void test1() throws MyException{
 ...
 if(....){
  throw new MyException();
 }
}</span>

将异常转型（也叫转译），使得异常更易读易于理解

<span style="font-size:18px;">public void test2() throws MyException{
 ...
 try{
  ...
 }catch(SQLException e){
  ...
  throw new MyException();
 }
}</span>

还有一个代码，很有意思：

<span style="font-size:18px;">public void test2() throws MyException{
 ...
 try {
  ...
 } catch (MyException e) {
  throw e;
 } 
}</span>

这段代码实际上捕获了异常，然后又和盘托出，没有一点意义，如果这样还有什么好处理的，不处理就行了，直接在方法前用throws声明抛出不就得了。异常的捕获就要做一些有意义的处理。

Java常见异常

在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()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常