Java基础篇：异常机制

目录：

一、为什么使用异常：

二、异常体系：

三、异常的捕捉–try、catch、finally：

一、为什么使用异常：

异常的处理机制可以确保我们程序的健壮性，提高系统可用率。在我们的程序设计当中，任何时候任何地方都有可能会出现异常，在没有异常机制的时候我们是这样处理的：通过函数的返回值来判断是否发生了异常（这个返回值通常是已经约定好了的），调用该函数的程序负责检查并且分析返回值。虽然可以解决异常问题，但是这样做存在几个缺陷：

（1）容易混淆。如果约定返回值为-1时表示出现异常，那么当程序最后的计算结果真的为-1呢？

（2）代码可读性差。将异常处理代码和程序代码混淆在一起将会降低代码的可读性。

（3）由调用函数来分析异常，这要求程序员对库函数有很深的了解。

在OOP中提供的异常处理机制是提供代码健壮的强有力的方式。使用异常机制它能够降低错误处理代码的复杂度，如果不使用异常，那么就必须检查特定的错误，并在程序中的许多地方去处理它，而如果使用异常，那就不必在方法调用处进行检查，因为异常机制将保证能够捕获这个错误，并且，只需在一个地方处理错误，即所谓的异常处理程序中。这种方式不仅节约代码，而且把“概述在正常执行过程中做什么事”的代码和“出了问题怎么办”的代码相分离。

二、异常体系：

Java基础篇：异常机制、

1、Throwable：

从上面这幅图可以看出，Throwable是java语言中所有错误和异常的超类（万物即可抛）。它有两个子类：Error、Exception。分别表示错误和异常。其中异常Exception分为运行时异常(RuntimeException)和非运行时异常（编译时异常），也称之为不检查异常(Unchecked Exception)和检查异常(Checked Exception)。

2、Error：

一般是指 Java 虚拟机相关的问题，大多数与代码编写与执行操作无关，如系统崩溃、虚拟机出错误、动态链接失败、线程死锁等，这种错误无法恢复或不可能捕获，将导致应用程序中断，通常应用程序无法处理这些错误，因此应用程序不应该捕获Error对象，也无须在其throws子句中声明该方法抛出任何Error或其子类。

3、Exception：

Exception是程序可以处理的异常，可以分为运行时异常与非运行时异常：

(1)运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。运行时异常表示程序运行过程中可能出现的非正常状态，这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

出现运行时异常后，如果没有捕获处理这个异常（即没有catch），系统会把异常一直往上层抛，一直到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。

(2)非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。如IOException、SQLException等以及用户自定义的Exception异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch并处理，否则程序就不能编译通过。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。

三、异常的捕捉–try、catch、finally：

对于异常的捕捉，一般使用try、catch、finally 。try快包含着可能出现异常的代码块，catch块捕获异常后对异常进行处理，finally代码块不论程序是否发生异常，总是会执行，所以finally一般用来关闭资源。

接下来看一个很典型的笔试题例子：

public int test2() {
		int i = 1;
		try {
			System.out.println("try语句块中");
			return 1;
		} finally {
			System.out.println("finally语句块中");
			return 2;
		}
	}

运行结果是：
try语句块中
finally语句块中
2

从运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

四、关于异常的题：

1、error和exception有什么区别？运行时异常与编译时异常的区别？（参考第2题回答）

2、Java中的异常处理机制的简单原理和应用：

（1）异常是指java程序运行时所发生的非正常情况或错误，Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error 和 Exception；

（2）Error 表示应用程序本身无法克服和恢复的一种严重问题，一般是指java虚拟机相关的问题，大多数与代码编写与执行操作无关，如系统崩溃、内存异常、虚拟机出错误、动态链接失败、线程死锁等，这种错误无法恢复或不可能捕获，通常应用程序无法处理这些错误，将导致应用程序中断。

（3）Exception表示程序还能够克服和恢复的问题，其中又分为运行时异常和编译时异常。运行时异常表示程序运行过程中可能出现的非正常状态，一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生，如数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）。非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。如IOException、SQLException等以及用户自定义的Exception异常。

（4）Java为运行时异常和编译时异常提供了不同的解决方案，编译器强制编译时异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，否则程序就不能编译通过，所以普通异常也称为checked异常，而运行时异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。

4，请写出你最常见到的5个runtime exception：

NullPointerException——程序试图访问一个空的数组中的元素或访问空的对象中的方法或变量时产生异常；

ArithmeticException——由于除数为0引起的异常；

ArrayIdexOutOfBoundsException——访问数组元素下标越界，引起异常；

IndexOutOfBoundsExcention——由于数组下标越界或字符串访问越界引起异常；

ClassCastException——当把一个对象归为某个类，但实际上此对象并不是由这个类创建的，也不是其子类创建的，则会引起异常；

OutofMemoryException——用new语句创建对象时，如系统无法为其分配内存空间则产生异常；

ClassNotFoundException——未找到指定名字的类或接口引起异常；

ArrayStoreException——当向数组中存放非数组声明类型对象时抛出。

NegativeArraySizeException——数组长度是负数，则产生异常；

IllegalMonitorStateException——监控器状态出错引起的异常；

SecurityException——由于访问了不应访问的指针，使安全性出问题而引起异常；

IOException——由于文件未找到、未打开或者I/O操作不能进行而引起异常；

CloneNotSupportedException——程序中的一个对象引用Object类的clone方法，但此对象并没有连接Cloneable接口，从而引起异常；

InterruptedException——当一个线程处于等待状态时，另一个线程中断此线程，从而引起异常；

NoSuchMethodException——所调用的方法未找到，引起异常；

IllegalAccessExcePtion——试图访问一个非public方法；

StringIndexOutOfBoundsException——访问字符串序号越界，引起异常；

NumberFormatException——字符的UTF代码数据格式有错引起异常；

IllegalThreadException——线程调用某个方法而所处状态不适当，引起异常；

FileNotFoundException——未找到指定文件引起异常；

EOFException——未完成输入操作即遇文件结束引起异常。

五、自定义异常：

Java确实给我们提供了非常多的异常，但是异常体系是不可能预见所有的希望加以报告的错误，所以Java允许我们自定义异常来表现程序中可能会遇到的特定问题，总之就是一句话：我们不必拘泥于Java中已有的异常类型。

Java自定义异常的使用要经历如下四个步骤：

1、定义一个类继承Throwable或其子类。

2、添加构造方法(当然也可以不用添加，使用默认构造方法)。

3、在某个方法类抛出该异常。

4、捕捉该异常。

/** 自定义异常 继承Exception类 **/
public class MyException extends Exception{
    public MyException(){
        
    }
    
    public MyException(String message){
        super(message);
    }
}
 
public class Test {
    public void display(int i) throws MyException{
        if(i == 0){
            throw new MyException("该值不能为0.......");
        }
        else{
            System.out.println( 2 / i);
        }
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        try {
            test.display(0);
            System.out.println("---------------------");
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

六、异常链：

在设计模式中有一个叫做责任链模式，该模式是将处理请求的多个对象链接成一条链，请求沿着这条链传递直到被接收、处理。同样Java异常机制也提供了这样一条链：异常链。

每遇到一个异常信息，我们都需要进行try…catch,一个还好，如果出现多个异常呢？分类处理肯定会比较麻烦，那就一个Exception解决所有的异常吧。这样确实是可以，但是这样处理势必会导致后面的维护难度增加。最好的办法就是将这些异常信息封装，然后捕获我们的封装类即可。

我们有两种方式处理异常，一是throws抛出交给上级处理，二是try…catch做具体处理。但是这个与上面有什么关联呢？try…catch的catch块我们可以不需要做任何处理，仅仅只用throw这个关键字将我们封装异常信息主动抛出来。然后在通过关键字throws继续抛出该方法异常。它的上层也可以做这样的处理，以此类推就会产生一条由异常构成的异常链。

通过使用异常链，我们可以提高代码的可理解性、系统的可维护性和友好性。

同理，我们有时候在捕获一个异常后抛出另一个异常信息，并且希望将原始的异常信息也保持起来，这个时候也需要使用异常链。

在异常链的使用中，throw抛出的是一个新的异常信息，这样势必会导致原有的异常信息丢失，如何保持？在Throwable及其子类中的构造器中都可以接受一个cause参数，该参数保存了原有的异常信息，通过getCause()就可以获取该原始异常信息。

语法：

public void test() throws XxxException{
        try {
            //do something:可能抛出异常信息的代码块
        } catch (Exception e) {
            throw new XxxException(e);
        }
    }

示例：

public class Test {
    public void f() throws MyException{
         try {
            FileReader reader = new FileReader("G:\\myfile\\struts.txt");  
             Scanner in = new Scanner(reader);  
             System.out.println(in.next());
        } catch (FileNotFoundException e) {
            //e 保存异常信息
            throw new MyException("文件没有找到--01",e);
        }  
    }
    
    public void g() throws MyException{
        try {
            f();
        } catch (MyException e) {
            //e 保存异常信息
            throw new MyException("文件没有找到--02",e);
        }
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        try {
            t.g();
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

运行结果:：

com.test9.MyException: 文件没有找到--02
    at com.test9.Test.g(Test.java:31)
    at com.test9.Test.main(Test.java:38)
Caused by: com.test9.MyException: 文件没有找到--01
    at com.test9.Test.f(Test.java:22)
    at com.test9.Test.g(Test.java:28)
    ... 1 more
Caused by: java.io.FileNotFoundException: G:\myfile\struts.txt (系统找不到指定的路径。)
    at java.io.FileInputStream.open(Native Method)
    at java.io.FileInputStream.<init>(FileInputStream.java:106)
    at java.io.FileInputStream.<init>(FileInputStream.java:66)
    at java.io.FileReader.<init>(FileReader.java:41)
    at com.test9.Test.f(Test.java:17)
    ... 2 more

如果在程序中去掉 e，也就是：throw new MyException(“文件没有找到–02”)；那么异常信息就保存不了，运行结果如下

com.test9.MyException: 文件没有找到--02
    at com.test9.Test.g(Test.java:31)
    at com.test9.Test.main(Test.java:38)

七、异常的使用误区：

首先我们先看如下示例：该实例能够反映java异常的不正确使用：

        OutputStreamWriter out = null;
        java.sql.Connection conn = null;
        try {            //   标注1
            Statement stat = conn.createStatement();
            ResultSet rs = stat.executeQuery("select *from user");
            while (rs.next()){
                out.println("name:" + rs.getString("name") + "sex:"
                        + rs.getString("sex"));
            }
            conn.close();         //标注2
            out.close();
        } 
        catch (Exception ex){    //标注3
            ex.printStackTrace();    //标注4
        }

1、标注1：

对于这个try…catch块，真正目的是捕获SQL的异常，但是这个try块是不是包含了太多的信息了。这是我们为了偷懒而养成的代码坏习惯。有些人喜欢将一大块的代码全部包含在一个try块里面，因为这样省事，反正有异常它就会抛出，而不愿意花时间来分析这个大代码块有那几块会产生异常，产生什么类型的异常，反正就是一篓子全部搞定。这就想我们出去旅游将所有的东西全部装进一个箱子里面，而不是分类来装，虽不知装进去容易，找出来难啊！！！所有对于一个异常块，我们应该仔细分清楚每块的抛出异常，因为一个大代码块有太多的地方会出现异常了。

结论一：尽可能减小try块！！！

2、标注2：

在这里你发现了什么？异常改变了运行流程！！不错就是异常改变了程序运行流程。如果该程序发生了异常那么conn.close(); out.close();是不可能执行得到的，这样势必会导致资源不能释放掉。所以如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，我们也要确保能够正确释放占用的资源。这里finally就有用武之地了：不管是否出现了异常，finally总是有机会运行的，所以finally用于释放资源是再适合不过了。

结论二：保证所有资源都被正确释放，充分运用finally关键词！！！

3、标注3：

对于这个代码我想大部分人都是这样处理的。使用这样代码的人都有这样一个心理，一个catch解决所有异常，这样是可以，但是不推荐！为什么！首先我们需要明白catch块所表示是它预期会出现何种异常，并且需要做何种处理，而使用Exception就表示他要处理所有的异常信息，但是这样做有什么意义呢？

这里我们再来看看上面的程序实例，很显然它可能需要抛出两个异常信息，SQLException和IOException。所以一个catch处理两个截然不同的Exception明显的不合适。如果用两个catch，一个处理SQLException、一个处理IOException就好多了。所以：

结论三：catch语句应当尽量指定具体的异常类型，而不应该指定涵盖涵盖范围太广的Exception类，不要一个Exception试图处理所有可能出现的异常！！！

4、标注4：

这里涉及到了两个问题，一是，捕获了异常不做处理，二是异常信息不够明确。

4.1、捕获异常不做处理，就是我们所谓的丢弃异常。我们都知道异常意味着程序出现了不可预期的问题，程序它希望我们能够做出处理来拯救它，但是你呢？一句ex.printStackTrace()搞定，这是多么的不负责任对程序的异常情况不理不顾。虽然这样在调试可能会有一定的帮助，但是调试阶段结束后呢？不是一句ex.printStackTrace()就可以搞定所有的事情的！那么怎么改进呢？有四种选择：

（1）处理异常。对所发生的的异常进行一番处理，如修正错误、提醒。再次申明ex.printStackTrace()算不上已经“处理好了异常”.

（2）重新抛出异常。既然你认为你没有能力处理该异常，那么你就尽情向上抛吧！！！

（3）封装异常。这是我认为最好的处理方法，对异常信息进行分类，然后进行封装处理。

（4）不要捕获异常。

4.2、异常信息不明确。我想对于这样的：java.io.FileNotFoundException: ………信息除了我们IT人没有几个人看得懂和想看吧！所以在出现异常后，我们最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一种更适合阅读的方式整理和组织printStackTrace提供的信息。起码我公司是需要将异常信息所在的类、方法、何种异常都需要记录在日志文件中的。

结论四：既然捕获了异常，就要对它进行适当的处理，不要捕获异常之后又把它丢弃，不予理睬！！！

结论五：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读！！！

对于异常还有以下几个注意地方：

结论六：不要在finally块中处理返回值！！！

结论七：不要在构造函数中抛出异常！！！

八：throw、throws：

throws是方法抛出异常。在方法声明中，如果添加了throws子句，表示该方法即将抛出异常，异常的处理交由它的调用者，至于调用者任何处理则不是它的责任范围内的了。所以如果一个方法会有异常发生时，但是又不想处理或者没有能力处理，就使用throws吧！

而throw是语句抛出异常。它不可以单独使用，要么与try…catch配套使用，要么与throws配套使用。

//使用throws抛出异常
    public void f() throws MyException{
         try {
            FileReader reader = new FileReader("G:\\myfile\\struts.txt");  
             Scanner in = new Scanner(reader);  
             System.out.println(in.next());
        } catch (FileNotFoundException e) {
            throw new MyException("文件没有找到", e);    //throw
        }  
        
    }