 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
抽象类、异常、集合
下载积分：600
内容提示：
文档格式：PDF|
浏览次数：3|
上传日期： 04:17:56|
文档星级：
该用户还上传了这些文档
抽象类、异常、集合.PDF
官方公共微信1394人阅读
作者：Maverick&blog：& 转载请注明出处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 =try{&&& con = dataSource.getConnection();&&& &&}catch(SQLException 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_ =&&& }
&&& public MyException(String s,Throwable cause)&&& {&&&&&&& super(s);&&&&&&& this.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块中，影响了代码执行的效率。参考资料[1]&& Joshua Bloch& Effective Java Programming Language Guide [2]&&
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：126735次
积分：1869
积分：1869
排名：第9601名
原创：58篇
转载：29篇
评论：75条
(1)(1)(1)(4)(1)(3)(1)(1)(1)(3)(4)(10)(4)(1)(1)(2)(9)(3)(3)(3)(2)(1)(6)(2)(3)(12)(3)(1)9151人阅读
&作者：Maverick
&blog：& 转载请注明出处
1. 课前练习
在阅读本文的内容之前，请从下面这段代码中找出异常处理有哪些不正确的地方。如果不能找出至少两处错误，说明你还是一个“菜鸟”，对JAVA的异常处理机制还不够了解，需要仔细阅读本文的内容，并走查一下自己编写的代码。如果你可以找出至少两处错误，恭喜你，你已经是一个熟悉JVAVA异常编码的老手了，如果有兴趣的话，请耐心阅读完本文，一起讨论一下JAVA异常处理的原则。
1 OutputStreamWriter out = ...
2 java.sql.Connection conn = ...
4 　& Statement stat = conn.createStatement();
5 　& ResultSet rs = stat.executeQuery(
6 　　&&& &select uid, name from user&);
7 　& while (rs.next())
9 　　&&& out.println(&ID：& + rs.getString(&uid&)
10 　　　&&& &，姓名：& + rs.getString(&name&));
12 　& conn.close();
13 　& out.close();
15 catch(Exception ex)
17 　 &e.printStackTrace();
2. 为什么需要异常处理机制
在JAVA语言出现以前，传统的异常处理方式多采用返回值来标识程序出现的异常情况，这种方式虽然为程序员所熟悉，但却有多个坏处。首先，一个API可以返回任意的返回值，而这些返回值本身并不能解释该返回值是否代表一个异常情况发生了和该异常的具体情况，需要调用API的程序自己判断并解释返回值的含义。其次，并没有一种机制来保证异常情况一定会得到处理，调用程序可以简单的忽略该返回值，需要调用API的程序员记住去检测返回值并处理异常情况。这种方式还让程序代码变得晦涩冗长，当进行IO操作等容易出现异常情况的处理时，你会发现代码的很大部分用于处理异常情况的switch分支，程序代码的可读性变得很差。
上面提到的问题，JAVA的异常处理机制提供了很好的解决方案。通过抛出JDK预定义或者自定义的异常,能够表明程序中出现了什么样的异常情况；而且JAVA的语言机制保证了异常一定会得到恰当的处理；合理的使用异常处理机制，会让程序代码清晰易懂。
3. JAVA异常类型
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。
&&& 第三类是一般的checkedException,这也是在编程中使用最多的Exception,所有继承自Exception并且不是RuntimeException的异常都是checked Exception，如图1中的IOException和ClassNotFoundException。JAVA 语言规定必须对checked Exception作处理，编译器会对此作检查，要么在方法体中声明抛出checked Exception,要么使用catch语句捕获checked Exception进行处理，不然不能通过编译。checked
Exception用于以下的语义环境：&
（1）checked Exception不是通过正确的编码就可以防止发生的问题，而是在程序运行期间经常会发生的异常情况。是我们在编码阶段需要考虑好如何处理的异常流程。例如进行ftp操作时网络断链、打开文件时文件已经被删除、用户登录时输入了错误的密码等。
（2）该异常发生后，可以通过对异常的恰当处理，恢复程序原来的正常处理流程。如一个Internet连接或者数据库连接发生异常被中止后，可以重试连接，重试成功后再进行后续操作。
（3）该异常发生后，虽然不能继续原来的处理流程，但进行一些处理后可以继续进行其他操作。例如用户登录时输入密码出错，界面模块接收到安全模块的鉴权失败异常后，通过对话框提示用户，用户可以选择退出登录或者重试。
4. JAVA异常的处理机制
当程序中抛出一个异常后，程序从程序中导致异常的代码处跳出，try块出现异常后的代码不会再被执行，java虚拟机检测寻找和try关键字匹配的处理该异常的catch块，如果找到，将控制权交到catch块中的代码，然后继续往下执行程序。
如果有finally关键字，程序中抛出异常后，无论该异常是否被catch,都会保证执行finally块中的代码。在try块和catch块采用return关键字退出本次函数调用，也会先执行finally块代码，然后再退出。即finally块中的代码始终会保证执行。由于finally块的这个特性，finally块被用于执行资源释放等清理工作。
如果程序发生的异常没有被catch(由于JAVA编译器的限制，只有uncheck exception会出现这种情况),执行代码的线程将被异常中止，即我们常常说的“线程跑飞了”。
5. JAVA异常处理中的原则和建议
合理使用JAVA异常机制可以使程序健壮而清晰，但不幸的是，JAVA异常处理机制常常被错误的使用，下面就是一些关于Exception的注意事项：
5.1. 原则：不要忽略checked Exception
请看下面的代码：
& & method1();& //method1抛出ExceptionA
catch(ExceptionA e)
& & e.printStackTrace();
JAVA编译器强制要求处理checkedexception,在很多代码中出现了上面这种情况，catch异常后只打印一下，然后继续执行下面的代码。上面的代码似乎没有什么问题，事实上在catch块中对发生的异常情况并没有作任何处理(打印异常不能是算是处理异常，因为打印并不能改变程序运行逻辑，修复异常)。这样程序虽然能够继续执行，但是由于这里的操作已经发生异常，将会导致以后的操作并不能按照预期的情况发展下去，可能导致两个结果：
一是由于这里的异常导致在程序中别的地方抛出一个异常，这种情况会使程序员在调试时感到迷惑，因为新的异常抛出的地方并不是程序真正发生问题的地方，也不是发生问题的真正原因；
另外一个是程序继续运行，并得出一个错误的输出结果，这种问题更加难以捕捉，因为很可能把它当成一个正确的输出。
那么应该如何处理呢，这里有四个选择：
（1）处理异常，进行修复以让程序继续执行。例如在进行数据库查询时，数据库连接断链后重建链接成功。
（2）在对异常进行分析后发现这里不能处理它，那么重新抛出异常，让调用者处理。异常依次向上抛出，如果所有方法都不能恰当地处理异常，最终会在用户界面以恰当的方式提示用户，由用户来判断下一步处理措施。例如在进行数据库查询时，断链后重试几次依然失败的情况。
（3）将异常转换为其他异常再抛出，这时应该注意不要丢失原始异常信息。这种情况一般用于将底层异常封装为应用层异常。
（4）不要捕获异常,直接在函数定义中使用throws声明将抛出该异常。让调用者去处理该异常。
因此，当捕获一个checked Exception的时候，必须对异常进行处理；如果认为不必要在这里作处理，就不要捕获该异常，在方法体中声明方法抛出异常，由上层调用者来处理该异常。
5.2. 建议：不要捕获unchecked Exception
有两种unchecked Exception：
Error：这种情况属于JVM发生了不可恢复的故障，例如内存溢出，无法处理。
RuntimeException：这种情况属于错误的编码导致的，出现异常后需要修改代码才能修复，一般来说catch后没有恰当的处理方式，因此不应该捕获。（该规则有例外情况，参见：5.11守护线程中需要catch runtime exception）
例如由于编码错误，下面的代码会产生ArrayIndexOutofBoundException。修改代码后才能修复该异常。
int[] intArray = new int[10];
intArray[10]=1;
5.3. 原则：不要一次捕获所有的异常
请看下面的代码：
& &method1();& //method1抛出ExceptionA
&&&method2();& //method1抛出ExceptionB
&&&method3();& //method1抛出ExceptionC
catch(Exception e)
这是一个很诱人的方案，代码中使用一个catch子句捕获了所有异常，看上去完美而且简洁，事实上很多代码也是这样写的。但这里有两个潜在的缺陷，一是针对try块中抛出的每种Exception，很可能需要不同的处理和恢复措施，而由于这里只有一个catch块，分别处理就不能实现。二是try块中还可能抛出RuntimeException,代码中捕获了所有可能抛出的RuntimeException而没有作任何处理，掩盖了编程的错误，会导致程序难以调试。
下面是改正后的正确代码：
& method1();& //method1抛出ExceptionA
&&&method2();& //method1抛出ExceptionB
&&&method3();& //method1抛出ExceptionC
catch(ExceptionA e)
catch(ExceptionB e)
catch(ExceptionC e)
5.4 &原则：使用finally块释放资源
什么是资源：程序中使用的数量有限的对象，或者只能独占式访问的对象。例如：文件、线程、线程池、数据库连接、ftp连接。因为资源是“有限的”，因此资源使用后必须释放，以避免程序中的资源被耗尽，影响程序运行。某些资源，使用完毕后会自动释放，如线程。某些资源则需要显示释放，如数据库连接。
& &finally关键字保证无论程序使用任何方式离开try块，finally中的语句都会被执行。在以下情况下，finally块的代码都会执行：
（1） try块中的代码正常执行完毕。
（2）在try块中抛出异常。
（3）在try块中执行return、break、continue。
（4） catch块中代码执行完毕。
（5）在catch块中抛出异常。
（6）在catch块中执行return、break、continue。
因此，当你需要一个地方来执行在任何情况下都必须执行的代码时，就可以将这些代码放入finally块中。当你的程序中使用了资源,如数据库连接，文件，Ftp连接，线程等，必须将释放这些资源的代码写入finally块中。
finally关键字可和catch关键字一起使用。如下：
catch(MyException e)
finally关键字也可以单独使用，不catch异常，将异常throw给调用者处理。
5.5.&&&&原则：finally块不能抛出异常
JAVA异常处理机制保证无论在任何情况下都先执行finally块的代码，然后再离开整个try，catch，finally块。在try，catch块中向外抛出异常的时候，JAVA虚拟机先转到finally块执行finally块中的代码，finally块执行完毕后，再将异常抛出。但如果在finally块中抛出异常，try，catch块的异常就不能抛出，外部捕捉到的异常就是finally块中的异常信息，而try，catch块中发生的真正的异常堆栈信息则丢失了。
请看下面的代码：
&Connection&con =
&&&con = dataSource.getConnection();
catch(SQLException e)
&&&//进行一些处理后再将数据库异常抛出给调用者处理
&&&&&&&con.close();
&&&catch(SQLException e)
&&& &&&&e.printStackTrace();
&& &&&&&……
运行程序后，调用者得到的信息如下
java.lang.NullPointerException
&atmyPackage.MyClass.method1(methodl.java:266)
而不是我们期望得到的数据库异常。这是因为这里的con是null的关系，在finally语句中抛出了NullPointerException,在finally块中增加对con是否为null的判断可以避免产生这种情况。
&5.6. &原则：异常不能影响对象的状态
异常产生后不能影响对象的状态，这是异常处理中的一条重要规则。在一个函数
中发生异常后，对象的状态应该和调用这个函数之前保持一致，以确保对象处于正确的状态中。
如果对象是不可变对象(不可变对象指调用构造函数创建后就不能改变的对象，即
&&& 创建后没有任何方法可以改变对象的状态)，那么异常发生后对象状态肯定不会改变。如果是可变对象，必须在编程中注意保证异常不会影响对象状态。有三个方法可以达到这个目的：
（1）将可能产生异常的代码和改变对象状态的代码分开，先执行可能产生异常的代码，如果产生异常，就不执行改变对象状态的代码。
（2）对不容易分离产生异常代码和改变对象状态代码的方法，定义一个recover方法，在异常产生后调用recover方法修复被改变的类变量，恢复方法调用前的类状态。
（3）在方法中使用对象的拷贝，这样当异常发生后，被影响的只是拷贝，对象本身不会受到影响。
&5.7. 原则：抛出自定义异常异常时带上原始异常信息
请看下面的代码：
public void method2()
& & & & &……
& & & & method1();& //method1进行了数据库操作
& & catch(SQLExceptione)
& & & & &……
& & & & throw new MyException(“发生了数据库异常:”+e.getMessage);
public void method3()
& & & & method2();
& & catch(MyExceptione)
& & & & 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类增加了两个构造方法,publicThrowable(Throwable cause)和public Throwable(String message,Throwable cause)，在构造函数中传入的原始异常堆栈信息将会在printStackTrace方法中打印出来。
5.8.&&&&原则：打印异常信息时带上异常堆栈
为便于分析异常原因，在进行异常输出时需要带上异常的堆栈，在进行编码时该问题容易忽视，需要注意,如下：
public void method3()
& & & & &method2();
& & catch(MyExceptione)
& & & & & & & ……//对异常进行处理
& & & & & & &System.out.println(e);//打印异常信息
System.out.println(e)相当于System.out.println(e.toString()),不能打印异常堆栈，不利于事后对异常进行分析。
&正确的打印方式：
public void method3()
& & & & &method2();
& & catch(MyExceptione)
& & & & & & &……//对异常进行处理
&& & & & & & &e.printStackTrace();//打印异常信息
5.9. 原则：不要使用同时使用异常机制和返回值来进行异常处理
请看下面一段代码
& & doSomething();
catch(MyException e)
& & if(e.getErrcode == -1)
& & & &……
& & if(e.getErrcode == -2)
& & & &……
假如在过一段时间后来看这段代码，你能弄明白是什么意思吗？混合使用JAVA异常处理机制和返回值使程序的异常处理部分变得“丑陋不堪”，并难以理解。如果有多种不同的异常情况，就定义多种不同的异常，而不要像上面代码那样综合使用Exception和返回值。
修改后的正确代码如下：
&&&doSomething();& //抛出MyExceptionA和MyExceptionB
catch(MyExceptionA e)
catch(MyExceptionB e)
5.10. &建议：不要让try块过于庞大
出于省事的目的，很多人习惯于用一个庞大的try块包含所有可能产生异常的代码，
这样有两个坏处：
阅读代码的时候，在try块冗长的代码中，不容易知道到底是哪些代码会抛出哪些异常，不利于代码维护。
使用try捕获异常是以程序执行效率为代价的，将不需要捕获异常的代码包含在try块中，影响了代码执行的效率。
5.11. 原则：守护线程中需要catch runtime exception
守护线程是指在需要长时间运行的线程，其生命周期一般和整个程序的时间一样长，用于提供某种持续的服务。例如服务器的告警定时同步线程，客户端的告警分发线程。由于守护线程需要长时间提供服务，因此需要对runtime exception进行保护，避免因为某一次偶发的异常而导致线程被终止。
while (true)
& & & & &doSomethingRepeted();
& & catch(MyExceptionA e)
& & & & //对checkedexception进行恰当的处理
& & & & ……
& & catch(RuntimeException e)
& & & & &//打印运行期异常，用于分析并修改代码
& & & & &e.printStackTrace();
[1]&& Joshua Bloch& Effective Java Programming Language Guide
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：77104次
积分：1072
积分：1072
排名：第18999名
原创：28篇
评论：26条
(1)(4)(2)(1)(2)(2)(1)(5)(2)(1)(1)(1)(1)(2)(1)(7)(2)(1)}