一、为什么要使用异常

      首先我们可以明确一点就是异常的处理机制可以确保我们程序的健壮性，提高系统可用率。虽然我们不是特别喜欢看到它，但是我们不能不承认它的地位，作用。有异常就说明程序存在问题，有助于我们及时改正。在我们的程序设计当做，任何时候任何地方因为任何原因都有可能会出现异常，在没有异常机制的时候我们是这样处理的：通过函数的返回值来判断是否发生了异常（这个返回值通常是已经约定好了的），调用该函数的程序负责检查并且分析返回值。虽然可以解决异常问题，但是这样做存在几个缺陷：

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

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

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

      在OO中提供的异常处理机制是提供代码健壮的强有力的方式。使用异常机制它能够降低错误处理代码的复杂度，如果不使用异常，那么就必须检查特定的错误，并在程序中的许多地方去处理它，而如果使用异常，那就不必在方法调用处进行检查，因为异常机制将保证能够捕获这个错误，并且，只需在一个地方处理错误，即所谓的异常处理程序中。这种方式不仅节约代码，而且把“概述在正常执行过程中做什么事”的代码和“出了问题怎么办”的代码相分离。总之，与以前的错误处理方法相比，异常机制使代码的阅读、编写和调试工作更加井井有条。（摘自《Think in java 》）。

      在初学时，总是听老师说把有可能出错的地方记得加异常处理，刚刚开始还不明白，有时候还觉得只是多此一举，现在随着自己的不断深入，代码编写多了，渐渐明白了异常是非常重要的。

 

二、基本定义

      在《Think in java》中是这样定义异常的：异常情形是指阻止当前方法或者作用域继续执行的问题。在这里一定要明确一点：异常代码某种程度的错误，尽管Java有异常处理机制，但是我们不能以“正常”的眼光来看待异常，异常处理机制的原因就是告诉你：这里可能会或者已经产生了错误，您的程序出现了不正常的情况，可能会导致程序失败！

      那么什么时候才会出现异常呢？只有在你当前的环境下程序无法正常运行下去，也就是说程序已经无法来正确解决问题了，这时它所就会从当前环境中跳出，并抛出异常。抛出异常后，它首先会做几件事。首先，它会使用new创建一个异常对象，然后在产生异常的位置终止程序，并且从当前环境中弹出对异常对象的引用，这时。异常处理机制就会接管程序，并开始寻找一个恰当的地方来继续执行程序，这个恰当的地方就是异常处理程序，它的任务就是将程序从错误状态恢复，以使程序要么换一种方法执行，要么继续执行下去。

     总的来说异常处理机制就是当程序发生异常时，它强制终止程序运行，记录异常信息并将这些信息反馈给我们，由我们来确定是否处理异常。

 

三、异常体系

      java为我们提供了非常完美的异常处理机制，使得我们可以更加专心于我们的程序，在使用异常之前我们需要了解它的体系结构：如下（该图摘自：）。

      从上面这幅图可以看出，Throwable是java语言中所有错误和异常的超类（万物即可抛）。它有两个子类：Error、Exception。

      其中Error为错误，是程序无法处理的，如OutOfMemoryError、ThreadDeath等，出现这种情况你唯一能做的就是听之任之，交由JVM来处理，不过JVM在大多数情况下会选择终止线程。

      而Exception是程序可以处理的异常。它又分为两种CheckedException（受捡异常），一种是UncheckedException（不受检异常）。其中CheckException发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。而UncheckedException发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的，难以排查，我们一般都需要纵观全局才能够发现这类的异常错误，所以在程序设计中我们需要认真考虑，好好写代码，尽量处理异常，即使产生了异常，也能尽量保证程序朝着有利方向发展。

      所以：对于可恢复的条件使用被检查的异常（CheckedException），对于程序错误（言外之意不可恢复，大错已经酿成）使用运行时异常（RuntimeException）。

      java的异常类实在是太多了，产生的原因也千变万化，所以下篇博文我将会整理，统计java中经常出现的异常，望各位关注！！

 

错误和异常的区别(Error vs Exception) 

1) java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。

java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。

2)  Error和RuntimeException 及其子类都是未检查的异常（unchecked exceptions），而所有其他的Exception类都是检查了的异常（checked exceptions）.

checked exceptions: 通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。检查了的异常发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。

unchecked exceptions: 通常是如果一切正常的话本不该发生的异常，但是的确发生了。发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。 因此，面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。

RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。

处理RuntimeException的原则是：如果出现 RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。其他（IOException等等）checked异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。 

 

四、异常使用

      在网上看了这样一个搞笑的话：世界上最真情的相依，是你在try我在catch。无论你发神马脾气，我都默默承受，静静处理。对于初学者来说异常就是try…catch，（鄙人刚刚接触时也是这么认为的，碰到异常就是try…catch）。个人感觉try…catch确实是用的最多也是最实用的。

      在异常中try快包含着可能出现异常的代码块，catch块捕获异常后对异常进行处理。先看如下实例：

public class ExceptionTest {    public static void main(String[] args) {        String file = "D:\\exceptionTest.txt";        FileReader reader;        try {            reader = new FileReader(file);            Scanner in = new Scanner(reader);              String string = in.next();              System.out.println(string + "不知道我有幸能够执行到不.....");        } catch (FileNotFoundException e) {            e.printStackTrace();            System.out.println("对不起,你执行不到...");        }          finally{            System.out.println("finally 在执行...");        }    }}

      从这个结果我们可以看出这些：

      1、当程序遇到异常时会终止程序的运行（即后面的代码不在执行），控制权交由异常处理机制处理。

      2、catch捕捉异常后，执行里面的函数。

不论程序是否发生异常，finally代码块总是会执行。所以finally一般用来关闭资源。

 

在这里我们发现两个异常之间存在如下区别：第二个异常信息多了Exception in thread "main"，这显示了出现异常信息的位置。在这里可以得到如下结论：若程序中显示的声明了某个异常，则抛出异常时不会显示出处，若程序中没有显示的声明某个异常，当抛出异常时，系统会显示异常的出处。

 

自定义异常

 

      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( i / 2);        }    }        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!！binge，正确！！但是如果仅仅只用throws抛出异常，那么你的封装类，怎么办？？

      我们有两种方式处理异常，一是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();        }    }}

 

七、异常的使用误区

      首先我们先看如下示例：该实例能够反映java异常的不正确使用（其实这也是我刚刚学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

      对于这个代码我想大部分人都是这样处理的，（LZ也是）。使用这样代码的人都有这样一个心理，一个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、封装异常。这是LZ认为最好的处理方法，对异常信息进行分类，然后进行封装处理。

      4、不要捕获异常。

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

      所以：

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

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

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

     六、不要在finally块中处理返回值。

    七、不要在构造函数中抛出异常。

 

八、try…catch、throw、throws

      在这里主要是区分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        }              }

 

九、总结

      其实对于异常使用的优缺点现在确实存在很多的讨论。例如：。这篇博文对于是否需要使用异常进行了比较深刻的讨论。LZ实乃菜鸟一枚，不能理解异常深奥之处。但是有一点LZ可以肯定，那就是异常必定会影响系统的性能。

      异常使用指南（摘自：Think in java）

      应该在下列情况下使用异常。

      1、在恰当的级别处理问题（在知道该如何处理异常的情况下才捕获异常）。

      2、解决问题并且重新调用产生异常的方法。

      3、进行少许修补，然后绕过异常发生的地方继续执行。

      4、用别的数据进行计算，以代替方法预计会返回的值。

      5、把当前运行环境下能做的事情尽量做完。然后把相同（不同）的异常重新抛到更高层。

      6、终止程序。

      7、进行简化。

      8、让类库和程序更加安全。（这既是在为调试做短期投资，也是在为程序的健壮做长期投资）

 

网上有很多人探讨Java中异常捕获机制try...catch...finally块中的finally语句是不是一定会被执行？很多人都说不是，当然他们的回答是正确的，经过我试验，至少有两种情况下finally语句是不会被执行的：

（1）try语句没有被执行到，如在try语句之前就返回了，这样finally语句就不会执行，这也说明了finally语句被执行的必要而非充分条件是：相应的try语句一定被执行到。

（2）在try块中有System.exit(0);这样的语句，System.exit(0);是终止Java虚拟机JVM的，连JVM都停止了，所有都结束了，当然finally语句也不会被执行到。

 

当然还有很多人探讨Finally语句的执行与return的关系，颇为让人迷惑，不知道finally语句是在try的return之前执行还是之后执行？我也是一头雾水，我觉得他们的说法都不正确，我觉得应该是：finally语句是在try的return语句执行之后，return返回之前执行。这样的说法有点矛盾，也许是我表述不太清楚，下面我给出自己试验的一些结果和示例进行佐证，有什么问题欢迎大家提出来。

public class FinallyTest1 {    public static void main(String[] args) {                System.out.println(test1());    }    public static int test1() {        int b = 20;        try {            System.out.println("try block");            return b += 80;         }        catch (Exception e) {            System.out.println("catch block");        }        finally {                        System.out.println("finally block");                        if (b > 25) {                System.out.println("b>25, b = " + b);            }        }                return b;    }    }

运行结果是：

try blockfinally blockb>25, b = 100100

说明return语句已经执行了再去执行finally语句，不过并没有直接返回，而是等finally语句执行完了再返回结果。

如果觉得这个例子还不足以说明这个情况的话，下面再加个例子加强证明结论：

public class FinallyTest1 {    public static void main(String[] args) {                System.out.println(test11());    }        public static String test11() {        try {            System.out.println("try block");           return test12();      } finally {           System.out.println("finally block");       }  }  public static String test12() {       System.out.println("return statement");       return "after return";   }    }

运行结果为：

try blockreturn statementfinally blockafter return

说明try中的return语句先执行了但并没有立即返回，等到finally执行结束后再

这里大家可能会想：如果finally里也有return语句，那么是不是就直接返回了，try中的return就不能返回了？看下面。

public class FinallyTest2 {    public static void main(String[] args) {        System.out.println(test2());    }    public static int test2() {        int b = 20;        try {            System.out.println("try block");            return b += 80;        } catch (Exception e) {            System.out.println("catch block");        } finally {            System.out.println("finally block");            if (b > 25) {                System.out.println("b>25, b = " + b);            }            return 200;        }        // return b;    }}

运行结果是：

try blockfinally blockb>25, b = 100200

这说明finally里的return直接返回了，就不管try中是否还有返回语句，这里还有个小细节需要注意，finally里加上return过后，finally外面的return b就变成不可到达语句了，也就是永远不能被执行到，所以需要注释掉否则编译器报错。

这里大家可能又想：如果finally里没有return语句，但修改了b的值，那么try中return返回的是修改后的值还是原值？看下面。

public class FinallyTest3 {    public static void main(String[] args) {        System.out.println(test3());    }    public static int test3() {        int b = 20;        try {            System.out.println("try block");            return b += 80;        } catch (Exception e) {            System.out.println("catch block");        } finally {            System.out.println("finally block");            if (b > 25) {                System.out.println("b>25, b = " + b);            }            b = 150;        }        return 2000;    }}

运行结果是：

try blockfinally blockb>25, b = 100100

测试用例2：

import java.util.*;public class FinallyTest6{    public static void main(String[] args) {        System.out.println(getMap().get("KEY").toString());    }         public static Map
     
       getMap() {        Map
      
        map = new HashMap
       
        ();        map.put("KEY", "INIT");                 try {            map.put("KEY", "TRY");            return map;        }        catch (Exception e) {            map.put("KEY", "CATCH");        }        finally {            map.put("KEY", "FINALLY");            map = null;        }                 return map;    }}
       
      
     

运行结果是：

FINALLY

为什么测试用例1中finally里的b = 150;并没有起到作用而测试用例2中finally的map.put("KEY", "FINALLY");起了作用而map = null;却没起作用呢？这就是Java到底是传值还是传址的问题了，具体请看，里面有详细的解答，简单来说就是：Java中只有传值没有传址，这也是为什么map = null这句不起作用。这同时也说明了返回语句是try中的return语句而不是 finally外面的return b;这句，不相信的话可以试下，将return b;改为return 294，对原来的结果没有一点影响。

这里大家可能又要想：是不是每次返回的一定是try中的return语句呢？那么finally外的return b不是一点作用没吗？请看下面。

public class FinallyTest4 {    public static void main(String[] args) {        System.out.println(test4());    }    public static int test4() {        int b = 20;        try {            System.out.println("try block");            b = b / 0;            return b += 80;        } catch (Exception e) {            b += 15;            System.out.println("catch block");        } finally {            System.out.println("finally block");            if (b > 25) {                System.out.println("b>25, b = " + b);            }            b += 50;        }        return 204;    }}

运行结果是：

try blockcatch blockfinally blockb>25, b = 3585

这里因 为在return之前发生了除0异常，所以try中的return不会被执行到，而是接着执行捕获异常的catch 语句和最终的finally语句，此时两者对b的修改都影响了最终的返回值，这时return b;就起到作用了。当然如果你这里将return b改为return 300什么的，最后返回的就是300，这毋庸置疑。

这里大家可能又有疑问：如果catch中有return语句呢？当然只有在异常的情况下才有可能会执行，那么是在finally之前就返回吗？看下面。

public class FinallyTest5 {    public static void main(String[] args) {        System.out.println(test5());    }    public static int test5() {        int b = 20;        try {            System.out.println("try block");                        b = b /0;            return b += 80;        } catch (Exception e) {            System.out.println("catch block");            return b += 15;        } finally {            System.out.println("finally block");            if (b > 25) {                System.out.println("b>25, b = " + b);            }            b += 50;        }        //return b;    }}

运行结果如下：

try blockcatch blockfinally blockb>25, b = 3535

说明了发生异常后，catch中的return语句先执行，确定了返回值后再去执行finally块，执行完了catch再返回，finally里对b的改变对返回值无影响，原因同前面一样，也就是说情况与try中的return语句执行完全一样。

最后总结：finally块的语句在try或catch中的return语句执行之后返回之前执行且finally里的修改语句可能影响也可能不影响try或catch中 return已经确定的返回值，若finally里也有return语句则覆盖try或catch中的return语句直接返回。