JAVA异常处理机制

1引子

try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。

package myExample.testException;

public class TestException {

public TestException() {

}

boolean testEx() throws Exception{

boolean ret = true;

try{

ret = testEx1();

}catch (Exception e){

System.out.println("testEx, catch exception");

ret = false;

throw e;

}finally{

System.out.println("testEx, finally; return value="+ret);

return ret;

}

}

boolean testEx1() throws Exception{

boolean ret = true;

try{

ret = testEx2();

if (!ret){

return false;

}

System.out.println("testEx1, at the end of try");

return ret;

}catch (Exception e){

System.out.println("testEx1, catch exception");

ret = false;

throw e;

}

finally{

System.out.println("testEx1, finally; return value="+ret);

return ret;

}

}

boolean testEx2() throws Exception{

boolean ret = true;

try{

int b=12;

int c;

for (int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}catch (Exception e){

System.out.println("testEx2, catch exception");

ret = false;

throw e;

}

finally{

System.out.println("testEx2, finally; return value="+ret);

return ret;

}

}

public static void main(String[] args) {

TestException testException1 = new TestException();

try{

testException1.testEx();

}catch(Exception e){

e.printStackTrace();

}

}

}

你的答案是什么？是下面的答案吗？

i=2

i=1

testEx2, catch exception

testEx2, finally; return value=false

testEx1, catch exception

testEx1, finally; return value=false

testEx, catch exception

testEx, finally; return value=false

如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。

现在公布正确答案：

i=2

i=1

testEx2, catch exception

testEx2, finally; return value=false

testEx1, finally; return value=false

testEx, finally; return value=false

2基础知识

2.1相关概念

例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是，这种错误处理机制会导致不少问题。

Java通过面向对象的方法来处理例外。在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。

2.2Throwable类及其子类

用面向对象的方法处理例外，就必须建立类的层次。类Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。

从图中可以看出，类Throwable有两个直接子类：Error和Exception。Error类对象(如动态连接错误等)，由Java虚拟机生成并抛弃(通常，Java程序不对这类例外进行处理)；Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。

图1例外处理的类层次

2.3异常处理关键字

Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的：

Throws:Lists the exceptions a method could throw.

Throw:Transfers control of the method to the exception handler.

Try：Opening exception-handling statement.

Catch：Captures the exception.

Finally：Runs its code before terminating the program.

2.3.1try语句

try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。

2.3.2catch语句

catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。

catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。

也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。

2.3.3finally语句

try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

2.3.4throws语句

throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或RuntimeException，或它们的子类，这个规则不起作用，因为这在程序的正常部分中是不期待出现的。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。

2.3.5throw语句

throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。

3关键字及其中语句流程详解

3.1try的嵌套

你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。

class MultiNest {

static void procedure() {

try {

int a = 0;

int b = 42/a;

} catch(java.lang.ArithmeticException e) {

System.out.println("in procedure, catch ArithmeticException: " + e);

}

}

public static void main(String args[]) {

try {

procedure();

} catch(java.lang. Exception e) {

System.out.println("in main, catch Exception: " + e);

}

}

}

这个例子执行的结果为：

in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero

成员函数procedure里有自己的try/catch控制，所以main不用去处理ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为：

in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero

in main, catch Exception: java.lang.ArithmeticException: / by zero

3.2try-catch程序块的执行流程以及执行结果

相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。

首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1．如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。

2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：

²如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块(也是离try最近的一个与异常V匹配的catch块)将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止(completes abruptly)”。

²如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止(completes abruptly)”。

3．如果try由于其他原因R突然中止(completes abruptly)，那么这个try-catch程序块的结果就是“由于原因R突然中止(completes abruptly)”。

3.3try-catch-finally程序块的执行流程以及执行结果

try-catch-finally程序块的执行流程以及执行结果比较复杂。

首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1．如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

²如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止(completes abruptly)”

2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：

²如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块(也是离try最近的一个与异常V匹配的catch块)将被执行；这时就会有两种执行结果：

²如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

²如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止(completes abruptly)”

²如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：

²如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止(completes abruptly)”。

²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止(completes abruptly)”，原因R将被抛弃。

(注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的(别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于)，所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。

如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。

这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。)

²如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止(completes abruptly)”。

²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止(completes abruptly)”，异常V将被抛弃。

3．如果try由于其他原因R突然中止(completes abruptly)，那么finally块被执行，分为两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止(completes abruptly)”。

²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止(completes abruptly)”，原因R将被抛弃。

3.4try-catch-finally程序块中的return

从上面的一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权(语句流程)转到finally块中；这种情况下一定要注意返回值的处理。

例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。

3.5如何抛出异常

如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：

第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。

boolean testEx2() throws Exception{

boolean ret = true;

int b=12;

int c;

for (int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}

第二种方式：使用try/catch，在catch中进行一定的处理之后(如果有必要的话)抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

boolean testEx2() throws Exception{

boolean ret = true;

try{

int b=12;

int c;

for (int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}catch (Exception e){

System.out.println("testEx2, catch exception");

Throw e;

}

}

第三种方法：使用try/catch/finally，在catch中进行一定的处理之后(如果有必要的话)抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

boolean testEx2() throws Exception{

boolean ret = true;

try{

int b=12;

int c;

for (int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

throw new Exception("aaa");

}

return true;

}catch (java.lang.ArithmeticException e){

System.out.println("testEx2, catch exception");

ret = false;

throw new Exception("aaa");

}finally{

System.out.println("testEx2, finally; return value="+ret);

}

}

4关于abrupt completion

前面提到了complete abruptly(暂且理解为“突然中止”或者“异常结束”吧)，它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。

4.1Normal and Abrupt Completion of Evaluation

每一个表达式(expression)都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束(complete normally)”；如果这个表达式的计算抛出了异常，就称为“异常结束(complete abruptly)”。异常结束通常有一个相关联的原因(associated reason)，通常也就是抛出一个异常V。

与表达式、操作符相关的运行期异常有：

²A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.

²An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.

²A field access throws a NullPointerException if the value of the object referenceexpression is null.

²A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.

²An array access throws a NullPointerException if the value of the array referenceexpression is null.

²An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.

²A cast throws a ClassCastException if a cast is found to be impermissible at run time.

²An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.

²An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.

4.2Normal and Abrupt Completion of Statements

正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况：

²break, continue, and return语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。

²某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因(或者说是阻止statement正常结束的原因)。

如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly.

导致abrupt completion的几种原因：

²A break with no label

²A break with a given label

²A continue with no label

²A continue with a given label

²A return with no value

²A return with a given value A

²throw with a given value, including exceptions thrown by the Java virtual machine

5关于我们的编程的一点建议

弄清楚try-catch-finally的执行情况后我们才能正确使用它。

如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了(finally语句块的最重要的作用应该是释放申请的资源)，因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值(除非在finally中抛出异常)。(我们需要记住：不仅throw语句是abrupt completion的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。)

1引言在JAVA语言出现以前，传统的异常处理方式多采用返回值来标识程序出现的异常情况，这种方式虽然为程序员所熟悉，但却有多个坏处。首先，一个API可以返回任意的返回值，而这些返回值本身并不能解释该返回值是否代表一个异常情况发生了和该异常的具体情况，需要调用API的程序自己判断并解释返回值的含义。其次，并没有一种机制来保证异常情况一定会得到处理，调用程序可以简单的忽略该返回值，需要调用API的程序员记住去检测返回值并处理异常情况。这种方式还让程序代码变得晦涩冗长，当进行IO操作等容易出现异常情况的处理时，你会发现代码的很大部分用于处理异常情况的switch分支，程序代码的可读性变得很差。上面提到的问题，JAVA的异常处理机制提供了很好的解决方案。通过抛出JDK预定义或者自定义的异常,能够表明程序中出现了什么样的异常情况；而且JAVA的语言机制保证了异常一定会得到恰当的处理；合理的使用异常处理机制，会让程序代码清晰易懂。2 JAVA异常的处理机制当程序中抛出一个异常后，程序从程序中导致异常的代码处跳出，java虚拟机检测寻找和try关键字匹配的处理该异常的catch块，如果找到，将控制权交到catch块中的代码，然后继续往下执行程序，try块中发生异常的代码不会被重新执行。如果没有找到处理该异常的catch块，在所有的finally块代码被执行和当前线程的所属的ThreadGroup的uncaughtException方法被调用后，遇到异常的当前线程被中止。3 JAVA异常的类层次JAVA异常的类层次如下图所示：图1 JAVA异常的类层次Throwable是所有异常的基类，程序中一般不会直接抛出Throwable对象，Exception和Error是Throwable的子类，Exception下面又有RuntimeException和一般的Exception两类。可以把JAVA异常分为三类：第一类是Error，Error表示程序在运行期间出现了十分严重、不可恢复的错误，在这种情况下应用程序只能中止运行，例如JAVA虚拟机出现错误。Error是一种unchecked Exception,编译器不会检查Error是否被处理,在程序中不用捕获Error类型的异常；一般情况下，在程序中也不应该抛出Error类型的异常。第二类是RuntimeException, RuntimeException是一种unchecked Exception，即表示编译器不会检查程序是否对RuntimeException作了处理，在程序中不必捕获RuntimException类型的异常，也不必在方法体声明抛出RuntimeException类。RuntimeException发生的时候，表示程序中出现了编程错误，所以应该找出错误修改程序，而不是去捕获RuntimeException。第三类是一般的checked Exception,这也是在编程中使用最多的Exception,所有继承自Exception并且不是RuntimeException的异常都是checked Exception，如图1中的IOException和ClassNotFoundException。JAVA语言规定必须对checked Exception作处理，编译器会对此作检查，要么在方法体中声明抛出checked Exception,要么使用catch语句捕获checked Exception进行处理，不然不能通过编译。checked Exception用于以下的语义环境：

(1)该异常发生后是可以被恢复的，如一个Internet连接发生异常被中止后，可以重新连接再进行后续操作。(2)程序依赖于不可靠的外部条件，该依赖条件可能出错，如系统IO。(3)该异常发生后并不会导致程序处理错误，进行一些处理后可以继续后续操作。

4 JAVA异常处理中的注意事项合理使用JAVA异常机制可以使程序健壮而清晰，但不幸的是，JAVA异常处理机制常常被错误的使用，下面就是一些关于Exception的注意事项：

1．不要忽略checked Exception请看下面的代码：try

{

method1();  //method1抛出ExceptionA

}

catch(ExceptionA e)

{

e.printStackTrace();

}上面的代码似乎没有什么问题，捕获异常后将异常打印，然后继续执行。事实上在catch块中对发生的异常情况并没有作任何处理(打印异常不能是算是处理异常，因为在程序交付运行后调试信息就没有什么用处了)。这样程序虽然能够继续执行，但是由于这里的操作已经发生异常，将会导致以后的操作并不能按照预期的情况发展下去，可能导致两个结果：一是由于这里的异常导致在程序中别的地方抛出一个异常，这种情况会使程序员在调试时感到迷惑，因为新的异常抛出的地方并不是程序真正发生问题的地方，也不是发生问题的真正原因；另外一个是程序继续运行，并得出一个错误的输出结果，这种问题更加难以捕捉，因为很可能把它当成一个正确的输出。那么应该如何处理呢，这里有四个选择：

(1)处理异常，进行修复以让程序继续执行。(2)重新抛出异常，在对异常进行分析后发现这里不能处理它，那么重新抛出异常，让调用者处理。(3)将异常转换为用户可以理解的自定义异常再抛出，这时应该注意不要丢失原始异常信息(见5)。(4)不要捕获异常。

因此，当捕获一个unchecked Exception的时候，必须对异常进行处理；如果认为不必要在这里作处理，就不要捕获该异常，在方法体中声明方法抛出异常，由上层调用者来处理该异常。

2．不要一次捕获所有的异常请看下面的代码：try

{

method1();  //method1抛出ExceptionA

method2();  //method1抛出ExceptionB

method3();  //method1抛出ExceptionC

}

catch(Exception e)

{

……

}这是一个很诱人的方案，代码中使用一个catch子句捕获了所有异常，看上去完美而且简洁，事实上很多代码也是这样写的。但这里有两个潜在的缺陷，一是针对try块中抛出的每种Exception，很可能需要不同的处理和恢复措施，而由于这里只有一个catch块，分别处理就不能实现。二是try块中还可能抛出RuntimeException,代码中捕获了所有可能抛出的RuntimeException而没有作任何处理，掩盖了编程的错误，会导致程序难以调试。下面是改正后的正确代码：try

{

method1();  //method1抛出ExceptionA

method2();  //method1抛出ExceptionB

method3();  //method1抛出ExceptionC

}

catch(ExceptionA e)

{

……

}

catch(ExceptionB e)

{

……

}

catch(ExceptionC e)

{

……

}

3．使用finally块释放资源finally关键字保证无论程序使用任何方式离开try块，finally中的语句都会被执行。在以下三种情况下会进入finally块：(1)try块中的代码正常执行完毕。(2)在try块中抛出异常。(3)在try块中执行return、break、continue。因此，当你需要一个地方来执行在任何情况下都必须执行的代码时，就可以将这些代码放入finally块中。当你的程序中使用了外界资源,如数据库连接，文件等，必须将释放这些资源的代码写入finally块中。必须注意的是，在finally块中不能抛出异常。JAVA异常处理机制保证无论在任何情况下必须先执行finally块然后在离开try块，因此在try块中发生异常的时候，JAVA虚拟机先转到finally块执行finally块中的代码，finally块执行完毕后，再向外抛出异常。如果在finally块中抛出异常，try块捕捉的异常就不能抛出，外部捕捉到的异常就是finally块中的异常信息，而try块中发生的真正的异常堆栈信息则丢失了。请看下面的代码：

Connection  con = null;

try

{

con = dataSource.getConnection();

……

}

catch(SQLException e)

{

……

throw e;//进行一些处理后再将数据库异常抛出给调用者处理}

finally

{

try

{

con.close();

}

catch(SQLException e)

{

e.printStackTrace();

……

}

}运行程序后，调用者得到的信息如下java.lang.NullPointerException

at myPackage.MyClass.method1(methodl.java:266)而不是我们期望得到的数据库异常。这是因为这里的con是null的关系，在finally语句中抛出了NullPointerException,在finally块中增加对con是否为null的判断可以避免产生这种情况。

4．异常不能影响对象的状态异常产生后不能影响对象的状态，这是异常处理中的一条重要规则。在一个函数中发生异常后，对象的状态应该和调用这个函数之前保持一致，以确保对象处于正确的状态中。如果对象是不可变对象(不可变对象指调用构造函数创建后就不能改变的对象，即创建后没有任何方法可以改变对象的状态)，那么异常发生后对象状态肯定不会改变。如果是可变对象，必须在编程中注意保证异常不会影响对象状态。有三个方法可以达到这个目的：(1)将可能产生异常的代码和改变对象状态的代码分开，先执行可能产生异常的代码，如果产生异常，就不执行改变对象状态的代码。(2)对不容易分离产生异常代码和改变对象状态代码的方法，定义一个recover方法，在异常产生后调用recover方法修复被改变的类变量，恢复方法调用前的类状态。(3)在方法中使用对象的拷贝，这样当异常发生后，被影响的只是拷贝，对象本身不会受到影响。

5．丢失的异常请看下面的代码：public void method2()

{

try

{

……

method1();  //method1进行了数据库操作}

catch(SQLException e)

{

……

throw new MyException(“发生了数据库异常:”+e.getMessage);

}

}

public void method3()

{

try

{

method2();

}

catch(MyException e)

{

e.printStackTrace();

……

}

}上面method2的代码中，try块捕获method1抛出的数据库异常SQLException后，抛出了新的自定义异常MyException。这段代码是否并没有什么问题，但看一下控制台的输出：MyException:发生了数据库异常：对象名称'MyTable'无效。at MyClass.method2(MyClass.java:232)

at MyClass.method3(MyClass.java:255)原始异常SQLException的信息丢失了，这里只能看到method2里面定义的MyException的堆栈情况；而method1中发生的数据库异常的堆栈则看不到，如何排错呢，只有在method1的代码行中一行行去寻找数据库操作语句了，祈祷method1的方法体短一些吧。JDK的开发者们也意识到了这个情况，在JDK1.4.1中，Throwable类增加了两个构造方法,public Throwable(Throwable cause)和public Throwable(String message,Throwable cause)，在构造函数中传入的原始异常堆栈信息将会在printStackTrace方法中打印出来。但对于还在使用JDK1.3的程序员，就只能自己实现打印原始异常堆栈信息的功能了。实现过程也很简单，只需要在自定义的异常类中增加一个原始异常字段，在构造函数中传入原始异常，然后重载printStackTrace方法，首先调用类中保存的原始异常的printStackTrace方法，然后再调用super.printStackTrace方法就可以打印出原始异常信息了。可以这样定义前面代码中出现的MyException类：public class MyExceptionextends Exception

{

//构造函数public SMException(Throwable cause)

{

this.cause_ = cause;

}

public MyException(String s,Throwable cause)

{

super(s);

this.cause_ = cause;

}

//重载printStackTrace方法，打印出原始异常堆栈信息public void printStackTrace()

{

if (cause_ != null)

{

cause_.printStackTrace();

}

super.printStackTrace(s);

}

public void printStackTrace(PrintStream s)

{

if (cause_ != null)

{

cause_.printStackTrace(s);

}

super.printStackTrace(s);

}

public void printStackTrace(PrintWriter s)

{

if (cause_ != null)

{

cause_.printStackTrace(s);

}

super.printStackTrace(s);

}

//原始异常private Throwable cause_;

}

6．不要使用同时使用异常机制和返回值来进行异常处理下面是我们项目中的一段代码try

{

doSomething();

}

catch(MyException e)

{

if(e.getErrcode == -1)

{

……

}

if(e.getErrcode == -2)

{

……

}

……

}假如在过一段时间后来看这段代码，你能弄明白是什么意思吗？混合使用JAVA异常处理机制和返回值使程序的异常处理部分变得“丑陋不堪”，并难以理解。如果有多种不同的异常情况，就定义多种不同的异常，而不要像上面代码那样综合使用Exception和返回值。修改后的正确代码如下：try

{

doSomething();  //抛出MyExceptionA和MyExceptionB

}

catch(MyExceptionA e)

{

……

}

catch(MyExceptionB e)

{

……

}

7．不要让try块过于庞大出于省事的目的，很多人习惯于用一个庞大的try块包含所有可能产生异常的代码，这样有两个坏处：阅读代码的时候，在try块冗长的代码中，不容易知道到底是哪些代码会抛出哪些异常，不利于代码维护。使用try捕获异常是以程序执行效率为代价的，将不需要捕获异常的代码包含在try块中，影响了代码执行的效率。