异常机制及其处理

一、异常

　　异常就是一个表示阻止执行正常进行的错误或者情况。比如数组下标越界访问异常：ArrayIndexOutOfBoundsException;文件不存在异常：FileNotFoundException等等。

 

抛出异常与异常处理的例子：除数为0异常。

package demo;

import java.util.Scanner;

/**
 * Created by luts on 2015/11/28.
 */
public class QuotientWithException {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        System.out.println("输入两个数:");
        int num1 = input.nextInt();
        int num2 = input.nextInt();

        try {
            if (num2 == 0)
                throw new ArithmeticException("除数不能为0");
            System.out.println(num1 + " / " + num2 + " = " + (num1 / num2));
        }
        catch (ArithmeticException ex){
            System.out.println("除数不能为0");
        }

        System.out.println("除法运算结束");
    }
}

输出：

输入两个数:
3
0
除数不能为0
除法运算结束

输入两个数:
6
3
6 / 3 = 2
除法运算结束

上述例子中，try语句是正常执行情况下的代码，如果出现异常则抛出异常。catch语句是对异常情况的处理。当程序中抛出一个异常的时候，程序的正常流程就被破坏了。throw语句用于抛出一个异常，类似于方法的调用，其调用的是catch块。catch块处理完异常后，不返回throw语句，而是执行catch块的下一条语句。

一个try-throw-catch块的模板为：

　　try {
        Code to try;
        Throw an exception with a throw statement or from method if necessary;
        more code to try;
        }
    catch (type ex){
        Code to process the exception;
        }

1.1. 异常的类型

　　

throwable类是所有异常类的根。所有异常类都直接或间接的继承自throwable类。可以通过Exception 或者Exception 的子类来创建自己的异常类。异常类大体分为三类：系统错误、异常和运行时异常。

　　· 系统错误（system error）：有java虚拟机抛出，用Error类表示。Error类描述的是内部系统错误，无法对错误进行处理。

　　· 异常（exception）：用Exception类表示，描述的是程序和外部环境所引起的错误，这些错误是能被程序捕获和处理的。

　　· 运行时异常（runtime exception）：用RuntimeException类表示，描述的是程序设计的错误。

Error类的子类例子：

类	可能引起异常的原因
LinkageError	一个类对另一个类由某种依赖性，编译前者后，后者变得不兼容
VirtualMachineError	Java虚拟机中断或者没有继续运行所必需的资源可用

Exception类的子类例子：

类	可能引起异常的原因
ClassNotFoundException	企图使用一个不存在的类。例如试图使用Java命令来运行一个不存的类或者程序要调用三个类文件，而只能找到两个，都会发生这种异常。
IOException	同输入/输出相关的操作，例如，无效的输入、读文件时超出文件尾、打开一个不存在的文件等。

RuntimeException类子类的例子：

类	可能引起异常的原因
ArithmetricException	一个整数除以0.  注意：浮点运算不抛出异常
NullPointerException	企图通过一个null引用变量访问一个对象
IndexOutOfBoundsException	数组下标越界
IllegalArgumentException	传递给方法的参数非法或者不合适

通常情况下，免检异常都会反映出程序设计上不可恢复的逻辑错误。为了避免过多使用try-catch块，java语言不允许编写代码捕获或声明免检异常。

1.2. 异常的处理

　　java的异常处理模型包括：声明一个异常、抛出一个异常和捕获一个异常。

1.2.1 声明异常

　　声明异常：每个方法都必须声明它可能抛出的必检异常的类型。因为任何代码都可能在程序中发生系统错误或者运行时错误，所以不要求显示声明Error和RuntimeException(免检异常)。声明异常的语法：

抛出一个异常：
public void myMethod() throws IOException

抛出多个异常：
public void myMethod() throws IOException1,throws IOException2, ..., throws IOExceptionN

注意：如果在父类中没有声明异常，那么在子类中就不能对其进行覆盖来声明异常。

1.2.2. 抛出异常

　　检测一个错误的程序可以创建一个正确的异常类型的实例并抛出它，这就称为抛出异常。

例如程序调用方法时传递的参数不符合方法的签名，可以创建一个IllegalArgumentException的实例并抛出它：

IllegalArgumentException ex = new IllegalArgumentException("Wrong Arguments");
throw ex;


或者使用下列语句：
throw new IllegalArgumentException("Wrong Arguments");

注意：声明异常使用关键字throws，抛出异常使用关键字throw。

1.2.3. 捕获异常

使用try-catch块来捕获异常：

try{
    statements; //statemenrs that may throw exceptions
}
catch(Exception1 exVar1){
    handle for Exception1 ;
}
catch(Exception2 exVar2){
    handle for Exception2 ;
}

...

catch(ExceptionN exVarN){
    handle for ExceptionN ;
}

　　· 如果在try块中没出现异常，则跳过catch块语句。

　　 · 如果try块中的某条语句抛出了一个异常，java就会跳过try块中剩下的语句，然后开始查找处理这个异常的代码的过程。处理这个异常的代码称为异常处理器；可以从当前方法开始，沿着调用方法的调用链，按照异常的反向传播方向找到这个处理器。从第一个到最后一个逐一检查catch块，判断是catch块中的异常实例是否是该异常对象的类型。如果是，就将该异常对象赋值给所声明的变量，然后执行catch块中的代码。如果没有发现异常处理器，java会退出这个方法，把异常传递给调用方法的方法，继续同样的过程来查找处理器。如果在调用的方法链中都找不到处理器，程序就会终止并且在控制台上打印出错信息。

　　 需要注意的是：

　　　　·  一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

　　　　· 一个通用父类可以派生各种异常类。如果一个catch块可以捕获一个父类的异常对象，那么它就能捕获那个父类的所有子类的异常对象。

　　　　· 子类的catch块必须出现在父类的catch块之前，否则会导致编译错误。正确的例子：

try{
   ....
}
catch (RuntimeException ex){
   ....
}
catch (Exception ex){
  ....
}

 　　　　· java强迫程序员必须处理必检异常。如果一个方法中声明了一个必检异常，就必须在try-catch块中调用它，或者在调用方法中声明要抛出的异常。

假设方法P1调用方法P2，P2可能会抛出一个IOException异常，那么代码编写有两种方式：

捕获异常：
void p1(){
    try{
        p2();
    }
    catch (IOException ex){
    ......
    }
}



或者抛出异常：
void p1() throws IOException {
    p2();    
}

一个完整的声明、抛出、捕获异常的例子：

package demo;

/*
 * 利用Circle类的setRadius方法操作如何声明、抛出和捕获异常
 * Created by luts on 2015/11/29.
 */
public class CircleWithException {

    private double radius;  //圆的半径

    private static int numberOfObjects = 0;     //记录实例对象的个数

    //构建一个半径为1的圆
    public CircleWithException(){
        this(1.0);
    }


    //构建一个指定半径的圆
    public CircleWithException(double newRadius){
        setRadius(newRadius);
        numberOfObjects++;
    }

    //访问器
    public double getRadius(){
        return radius;
    }

    //设置器，声明异常、抛出异常
    public void setRadius(double newRadius) throws IllegalArgumentException{
        if (newRadius >= 0)
            radius = newRadius;
        else throw new IllegalArgumentException("Radius cannot be negative");
    }

    public static int getNumberOfObjects(){
        return numberOfObjects;
    }

    public double findArea(){
        return radius * radius * Math.PI;
    }
}

package demo;

/**
 * Created by luts on 2015/11/29.
 */
public class TestCircleWithException {
    public static void main(String[] args){

        //捕获异常
        try {
            CircleWithException c1 = new CircleWithException(5);
            CircleWithException c2 = new CircleWithException(-5);
            CircleWithException c3 = new CircleWithException(0);
        }
        catch (IllegalArgumentException ex){
            System.out.println(ex);
        }

        System.out.println("Number of objects created: " + CircleWithException.getNumberOfObjects());
    }
}

输出结果：

java.lang.IllegalArgumentException: Radius cannot be negative
Number of objects created: 1

1.2.4. 从异常中获取信息

　　异常对象包含关于异常信息的有用信息，这些信息可以通过java.lang.Throwable类中的实例方法获得：

　　· printStackTrace()方法在控制台上输出栈跟踪信息。

　　· getStackTrace()方法提高方案来访问由 printStackTrace()打印输出的栈跟踪信息。

例如上述例子，将测试类修改如下：

package demo;

/**
 * Created by luts on 2015/11/29.
 */
public class TestCircleWithException {
    public static void main(String[] args){

        //捕获异常
        try {
            CircleWithException c1 = new CircleWithException(5);
            CircleWithException c2 = new CircleWithException(-5);
            CircleWithException c3 = new CircleWithException(0);
        }
        catch (IllegalArgumentException ex){
            ex.printStackTrace();
            System.out.println("
" + ex.getMessage());
            System.out.println("
" + ex.toString());


            System.out.println("
Trace Info Obtained from getStackTrace");
            StackTraceElement[] traceElements = ex.getStackTrace();
            for (int i = 0; i < traceElements.length; i++) {
                System.out.print("method " + traceElements[i].getMethodName());
                System.out.print("(" + traceElements[i].getClassName() + ":");
                System.out.print( traceElements[i].getLineNumber() + ")");
            }


           // System.out.println(ex);  //打印一个有关异常信息的短信息ex.toStrin()
        }

        System.out.println("Number of objects created: " + CircleWithException.getNumberOfObjects());
    }
}

控制台输出：

java.lang.IllegalArgumentException: Radius cannot be negative　　　　<-------printStackTrac()

    at demo.CircleWithException.setRadius(CircleWithException.java:34)　　　<--------getMessage()　
Radius cannot be negative
    at demo.CircleWithException.<init>(CircleWithException.java:21)

    at demo.TestCircleWithException.main(TestCircleWithException.java:12)  <--------toString()
java.lang.IllegalArgumentException: Radius cannot be negative
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)  <------using getStackTrace()
Trace Info Obtained from getStackTrace                                 
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
method setRadius(demo.CircleWithException:34)method <init>(demo.CircleWithException:21)method main(demo.TestCircleWithException:12)method invoke0(sun.reflect.NativeMethodAccessorImpl:-2)method invoke(sun.reflect.NativeMethodAccessorImpl:62)method invoke(sun.reflect.DelegatingMethodAccessorImpl:43)method invoke(java.lang.reflect.Method:483)method main(com.intellij.rt.execution.application.AppMain:144)Number of objects created: 1
    at java.lang.reflect.Method.invoke(Method.java:483)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

1.2.5 finally子句

　　finally子句：不管是否发生异常，都会执行的语句，其语法如下：

try {
   .....
}
catch (TheException ex){
  .......
}
finally {
  fianlStatements;
}

　　任何情况下，finally块中的代码都会执行，不管try块中是否出现异常或是否捕获异常：

　　· 如果try块中没有出现异常，执行finalStatements，然后执行try语句的下一条语句。

　　· 如果try块中有一条语句会引起异常，并被catch块捕获，然后跳过try块中的其他语句，执行catch块和finally子句。执行try语句之后的下一条语句。

　　· 如果try块中有一条语句引起异常，但是没有被任何catch块捕获，就会跳出try块中其他的语句，执行finally子句，并且将异常传递给该方法的调用者。

　　即使在到达finally块之前有一个return语句，finally语句还是会执行。

finally例子：

public class TestException {  
    public static void main(String args[]) {  
        int i = 0;  
        String greetings[] = { " Hello world !", " Hello World !! ",  
                " HELLO WORLD !!!" };  
        while (i < 4) {  
            try {  
                // 特别注意循环控制变量i的设计，避免造成无限循环  
                System.out.println(greetings[i++]);  
            } catch (ArrayIndexOutOfBoundsException e) {  
                System.out.println("数组下标越界异常");  
            } finally {  
                System.out.println("--------------------------");  
            }  
        }  
    }  
}

输出结果：

 Hello world !
--------------------------
 Hello World !! 
--------------------------
 HELLO WORLD !!!
--------------------------
数组下标越界异常
--------------------------

小结：

　　·  try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。

　　·  catch 块：用于处理try捕获到的异常。
　　·  finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
　　　　　　1）在finally语句块中发生了异常。
　　　　　　2）在前面的代码中用了System.exit()退出程序。
　　　　　　3）程序所在的线程死亡。
　　　　　　4）关闭CPU。

 try-catch-finally 规则(异常处理语句的语法规则）：

　　1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。

　　2) 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
　　3) catch 块与相应的异常类的类型相关。
　　4) 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为

　　某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
　　5) 可嵌套 try-catch-finally 结构。
　　6) 在 try-catch-finally 结构中，可重新抛出异常。
　　7) 除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。

 

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语句块后的语句。

 1.2.6 重新抛出异常

　　如果异常处理器没有处理某种异常，或者处理器只是希望它的调用者注意到该异常，java就允许异常处理器重新抛出异常。语法如下：

try{
   .....
}
catch(TheException ex){
  perform operations before exits;
  throw ex;　　//重新抛出异常，以便调用者的其他处理器获得处理异常ex的机会。
}

异常链

package demo;

public class TestException {  
    public static void main(String args[]) {  
        try {
            method1();    //捕获method1中的异常
        }
        catch (Exception ex){
            ex.printStackTrace();  //打印输出异常，首先显示method1 中抛出的异常，然后显示method2中抛出的异常。
        }
    }  
    
    public static void method1() throws Exception{
        try{
            method2();   //捕获method2中的异常
        }
        catch(Exception ex){
            throw new Exception("New info from method1", ex);  //抛出一个新的异常
        }
    }
    
    public static void method2() throws Exception{
        throw new Exception("New info from metho2");  //抛出一个异常，该异常被method1 的catch块捕获
    }
}

输出：

java.lang.Exception: New info from method1
    at demo.TestException.method1(TestException.java:18)
    at demo.TestException.main(TestException.java:6)
Caused by: java.lang.Exception: New info from metho2
    at demo.TestException.method2(TestException.java:23)
    at demo.TestException.method1(TestException.java:15)
    ... 1 more

关于异常处理知识的深入知识，可以参阅：[深入理解java异常处理机制]