Java中的异常

异常概念：

实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序在跑着，内存或硬盘可能满了。等等。

软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception， 意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。

异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。

异常发生在程序运行期间,它影响了正常的程序执行流程。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error ；如果你用 System.out.println(11/0) ，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

　　用户输入了非法数据。

　　要打开的文件不存在。

　　网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

 

异常指不期而至的各种状况，如：文件找不到、网络连接失败、除0操作、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。

Java语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个异常类来表示，不同类型的异常对应不同的子类异常（目前我们所说的异常包括错误概念），定义异常处理的规范，在 JDK1.4 版本以后增加了异常链机制，从而便于跟踪异常。

 Java异常是一个描述在代码段中发生异常的对象，当发生异常情况时，一个代表该异常的对象被创建并且在导致该异常的方法中被抛出，而该方法可以选择自己处理异常或者传递该异常。

 

异常体系结构

Java把异常当作对象来处理，并定义一个基类 java.lang.Throwable 作为所有异常的超类。

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

Java异常层次结构图：

 

从图中可以看出所有异常类型都是内置类 Throwable 的子类，因而 Throwable 在异常类的层次结构的顶层。

 接下来 Throwable 分成了两个不同的分支，一个分支是Error，它表示不希望被程序捕获或者是程序无法处理的错误。另一个分支是Exception，它表示用户程序可能捕捉的异常情况或者说是程序可以处理的异常。

其中异常类 Exception 又分为运行时异常( RuntimeException )和非运行时异常。Java异常又可以分为不受检查异常（ Unchecked Exception ）和检查异常（ Checked Exception ）。

 

异常之间的区别与联系

　　1、Error

Error 类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

比如说：

Java虚拟机运行错误（ Virtual MachineError ），当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError 。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；

还有发生在虚拟机试图执行应用时，如类定义错误（ NoClassDefFoundError ）、链接错误（ LinkageError ）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。

对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在Java中，错误通常是使用 Error 的子类描述。

　　2、Exception

在 Exception 分支中有一个重要的子类 RuntimeException （运行时异常），该类型的异常自动为你所编写的程序定义 ArrayIndexOutOfBoundsException （数组下标越界）、 NullPointerException （空指针异常）、ArithmeticException （算术异常）、 MissingResourceException （丢失资源）、 ClassNotFoundException （找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；而 RuntimeException 之外的异常我们统称为非运行时异常，类型上属于 Exception 类及其子类， 从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如 IOException 、 SQLException 等以及用户自定义的 Exception 异常，一般情况下不自定义检查异常。

注意： Error 和 Exception 的区别： Error 通常是灾难性的致命的错误，是程序无法控制和 处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程； Exception 通常情况下是可 以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

　　3、检查异常和不受检查异常

检查异常：在正确的程序运行过程中，很容易出现的、情理可容的异常状况，在一定程度上这种异常的发生是可以预测的，并且一旦发生该种异常，就必须采取某种方式进行处理。

解析：除了RuntimeException及其子类以外，其他的Exception类及其子类都属于检查异常，当程序 中可能出现这类异常，要么使用try-catch语句进行捕获，要么用throws子句抛出，否则编译无法通过。

不受检查异常：包括RuntimeException及其子类和Error。

分析： 不受检查异常 为编译器不要求强制处理的异常， 检查异常 则是编译器要求必须处置的异常。

 

Java异常处理机制

java异常处理本质：抛出异常和捕获异常

　　1、抛出异常

要理解抛出异常，首先要明白什么是异常情形（exception condition），它是指阻止当前方法或作用域继续执行的问题。其次把异常情形和普通问题相区分，普通问题是指在当前环境下能得到足够的信息， 总能处理这个错误。

对于异常情形，已经无法继续下去了，因为在当前环境下无法获得必要的信息来解决问题，你所能做的 就是从当前环境中跳出，并把问题提交给上一级环境，这就是抛出异常时所发生的事情。抛出异常后， 会有几件事随之发生。

首先，是像创建普通的java对象一样将使用 new 在堆上创建一个异常对象；然后，当前的执行路径 （已经无法继续下去了）被终止，并且从当前环境中弹出对异常对象的引用。此时，异常处理机制接管 程序，并开始寻找一个恰当的地方继续执行程序，这个恰当的地方就是异常处理程序或者异常处理器，它的任务是将程序从错误状态中恢复，以使程序要 么换一种方式运行，要么继续运行下去。

举例：

假使我们创建了一个学生对象Student的一个引用stu,在调用的时候可能还没有初始化。所以在使用这个 对象引用调用其他方法之前，要先对它进行检查，可以创建一个代表错误信息的对象，并且将它从当前 环境中抛出，这样就把错误信息传播到更大的环境中。

if(stu == null){
    throw new NullPointerException();
}

　　2、捕获异常

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

注意：

对于 运行时异常 、 错误 和 检查异常 ，Java技术所要求的异常处理方式有所不同

由于运行时异常及其子类的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将 由Java运行时系统自动抛出，允许应用程序忽略运行时异常。

对于方法运行中可能出现的 Error ，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因 为，大多数 Error 异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。

对于所有的检查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法 选择不捕捉检查异常时，它必须声明将抛出异常。

　　3、异常处理五个关键字

 

 

处理异常

　　1、try -catch

try{
    //code that might generate exceptions
}catch(Exception e){
    //the code of handling exception1
}catch(Exception e){
    //the code of handling exception2
}

要明白异常捕获，还要理解 监控区域 （guarded region）的概念。它是一段可能产生异常的代码， 并且后面跟着处理这些异常的代码。

因而可知，上述 try-catch 所描述的即是监控区域，关键词 try 后的一对大括号将一块可能发生 异常的代码包起来，即为监控区域。Java方法在运行过程中发生了异常，则创建异常对象。

将异常抛出监控区域之外，由Java运行时系统负责寻找匹配的 catch 子句来捕获异常。若有一个 catch 语句匹配到了，则执行该 catch 块中的异常处理代码，就不再尝试匹配别的 catch 块 了。

匹配原则：如果抛出的异常对象属于 catch 子句的异常类，或者属于该异常类的子类，则认为生成 的异常对象与 catch 块捕获的异常类型相匹配。

【演示】

public class TestException {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try { // try监控区域
            if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出
            异常
            System.out.println("a/b的值是：" + a / b);
            System.out.println("this will not be printed!");
        }
        catch (ArithmeticException e) { // catch捕捉异常
            System.out.println("程序出现异常，变量b不能为0！");
        }
        System.out.println("程序正常结束。");
    }
}
//输出
程序出现异常，变量b不能为0！
        程序正常结束。

注意：显示一个异常的描述， Throwable 重载了 toString() 方法（由 Object 定义），所以 它将返回一个包含异常描述的字符串。例如，将前面的 catch 块重写成：

catch (ArithmeticException e) { // catch捕捉异常
    System.out.println("程序出现异常"+e);
}
//输出
程序出现异常java.lang.ArithmeticException
程序正常结束。

算术异常属于运行时异常，因而实际上该异常不需要程序抛出，运行时系统自动抛出。如果不用trycatch程序就不会往下执行了

【演示】

public class TestException {
    public static void main(String[] args) {
            int a = 1;
            int b = 0;
            System.out.println("a/b的值是：" + a / b);
            System.out.println("this will not be printed!");
    }
}
结果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at TestException.main(TestException.java:7)

使用多重的catch语句：很多情况下，由单个的代码段可能引起多个异常。处理这种情况，我们需要定 义两个或者更多的 catch 子句，每个子句捕获一种类型的异常，当异常被引发时，每个 catch 子 句被依次检查，第一个匹配异常类型的子句执行，当一个 catch 子句执行以后，其他的子句将被旁路。

编写多重catch语句块注意事项：

　　顺序问题：先小后大，即先子类后父类

　　2、thorw

到目前为止，我们只是获取了被Java运行时系统引发的异常。然而，我们还可以用 throw 语句抛出明 确的异常。

 语法形式：

throw ThrowableInstance;

这里的ThrowableInstance一定是 Throwable 类类型或者 Throwable 子类类型的一个对象。简单 的数据类型，例如 int ， char ,以及非 Throwable 类，例如 String 或 Object ，不能用 作异常。

序执行完 throw 语句之后立即停止； throw 后面的任何语句不被执行，最邻近的 try 块用来检 查它是否含有一个与异常类型匹配的 catch 语句。

如果发现了匹配的块，控制转向该语句；如果没有发现，次包围的 try 块来检查，以此类推。如果没 有发现匹配的 catch 块，默认异常处理程序中断程序的执行并且打印堆栈轨迹。

class TestThrow{
static void proc(){
try{
throw new NullPointerException("demo");
}catch(NullPointerException e){
System.out.println("Caught inside proc");
throw e;
}
}
public static void main(String [] args){
try{
proc();
}catch(NullPointerException e){
System.out.println("Recaught: "+e);
}
}
}

该程序两次处理相同的错误，首先， main() 方法设立了一个异常关系然后调用proc()。proc()方法设 立了另一个异常处理关系并且立即抛出一个 NullPointerException 实例， NullPointerException 在 main() 中被再次捕获。

该程序阐述了怎样创建Java的标准异常对象，特别注意这一行：

throw new NullPointerException("demo");

分析：此处 new 用来构造一个 NullPointerException 实例，所有的Java内置的运行时异常有两 个构造方法：一个没有参数，一个带有一个字符串参数。

当用第二种形式时，参数指定描述异常的字符串。如果对象用作 print() 或者 println() 的参数 时，该字符串被显示。这同样可以通过调用getMessage()来实现，getMessage()是由 Throwable 定 义的。

　　3、throws

如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己 而不发生异常。要做到这点，我们可以在方法声明中包含一个 throws 子句。

一个 throws 子句列举了一个方法可能引发的所有异常类型。这对于除了 Error 或 RuntimeException 及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他类型的 异常必须在 throws 子句中声明，否则会导致编译错误

public void info() throws Exception
{
    //body of method
}

Exception 是该方法可能引发的所有的异常,也可以是异常列表，中间以逗号隔开。

class TestThrows{
    static void throw1() throws IllegalAccessException {
        System.out.println("Inside throw1 . ");
        throw new IllegalAccessException("demo");
    }
    public static void main(String[] args){
        try {
            throw1();
        }catch(IllegalAccessException e ){
        System.out.println("Caught " + e);
        }
    }
}

 

 

自定义异常：

class MyException extends Exception {
    private int detail;
    MyException(int a){
        detail = a;
    }
    public String toString(){
        return "MyException ["+ detail + "]";
    }
}
public class TestMyException{
    static void compute(int a) throws MyException{
        System.out.println("Called compute(" + a + ")");
        if(a > 10){
            throw new MyException(a);
        }
        System.out.println("Normal exit!");
    }
    
    public static void main(String [] args){
        try{
            compute(1);
            compute(20);
        }catch(MyException me){
            System.out.println("Caught " + me);
        }
    }
}