Java 中的异常处理从概念到实例

核心提示：1、概念采用新的异常处理机制在以往的程序开发过程中，经常采用返回值进行处理，Java 中的异常处理从概念到实例，例如，在编写一个方法，激发的异常携带错误类或异常方法的路径：如：setFlag(“PSI001”);throw new WhcaException(“JB:TestA M:exe1 ”+e.getMessag

　　1、概念
　　采用新的异常处理机制
　　在以往的程序开发过程中，经常采用返回值进行处理。例如，在编写一个方法，可以返回一个状态代码，调用者根据状态代码判定出错与否。若状态代码表示一个错误，则调用这进行相应的处理，或显示一个错误页面或错误信息。通过返回值进行处理的方法是有效的，但是有它的许多不足之处。
　　
　　1、　程序复杂
　　
　　2、　可靠性差
　　
　　3、　返回信息有限
　　
　　4、　返回代码标准化困难
　　
　　采用错误代码和异常处理相结合的方式的优越性：
　　
　　1、　把错误代码与常规代码分开
　　
　　2、　可以在catch中传播错误信息
　　
　　3、　可以对错误类型分组
　　
　　4、　方便定位错误，维护
　　
　　异常
　　异常就是异常事件，它是程序碰到异常情况所激发的事件。许多异常，如程序错误，空指针，数组溢出等。下面是一个出错流程
　　
　　第一步：插入用户的Keynet，登录系统
　　
　　第二步：服务器验证用户的身份，判定用户的权限
　　
　　第三步：返回错误的信息。
　　
　　这是一个简单的异常处理示例，怎样简单、方便、快捷的得到错误信息。可以采用错误代码和异常两种方式相结合的方式处理。
　　
　　2、异常处理
　　java的异常是面向对象的。一个Java的Exception是一个描述异常情况的对象.当出现异常情况时，一个Exception对象就产生了,并放到异常的成员函数里。
　　
　　Java的异常处理是通过5个要害词来实现的：try,catch,throw,throws和finally。在Java语言的错误处理结构由try，catch，finally三个块组成。其中try块存放将可能发生异常的Java语言，并治理相关的异常指针；catch块紧跟在try块后面，用来激发被捕捉的异常；finally块包含清除程序没有释放的资源，句柄等。不管try块中的代码如何退出，都将执行finally块。
　　
　　try… catch… 块
　　可以采用try来指定一块预防所有异常的程序。紧跟在try程序块后面，应包含一个
　　
　　或多个catch子句来指定你想要捕捉的异常类型：try catch的格式一般为：
　　
　　try{
　　
　　/**do something*/
　　
　　}catch(…){
　　
　　…
　　
　　}catch(…){
　　
　　　　…
　　
　　}
　　
　　例如：
　　
　　try{
　　
　　int a= 100/0
　　
　　}catch(Exception e){
　　
　　System.out.PRintln(e.getMessage());
　　
　　}
　　
　　每当Java程序激发一个异常时，它实际上是激发了一个对象，而只有其超类为Throwable类的对象才能被激发。Throwable类中的提供了一些方法。如：其中的getMessage()方法打印出异常对应信息。
　　
　　Catch子句的目标是解决异常情况，把变量设到合理的状态，并象没有出错一样继续运行。假如一个子程序不处理没个异常，则返回到上一级处理，如此可以不断的递归向上直到最外一级。
　　
　　finally 块
　　finally 要害字是对 Java 异常处理模型的最佳补充。 finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。假如没有 finally，您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您必须如何编写代码来释放非内存资源：
　　
　　import java.net.*;
　　import java.io.*;
　　class WithoutFinally
　　{
　　　public void foo() throws IOException
　　　{
　　　　//在任一个空闲的端口上创建一个套接字
　　　　ServerSocket ss = new ServerSocket(0);
　　　　try {
　　　　　Socket socket = ss.accept();
　　　　　//此处的其他代码...
　　　　}
　　　　catch (IOException e) {
　　　　　ss.close();　　　　　　　　　　　　　　　　　　　　　　 //1
　　　　　throw e;
　　　　}
　　
　　　　//...
　　　　ss.close();　　　　　　　　　　　　　　　　　　　　　　　 //2
　　　}
　　}
　　这段代码创建了一个套接字，并调用 accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在 //2 处调用 close，它是该方法的最后一条语句。但是，假如 try 块中发生一个异常会怎么样呢？在这种情况下，//2 处的 close 调用永远不会发生。因此，您必须捕捉这个异常，并在重新发出这个异常之前在 //1 处插入对 close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。
　　
　　这样编写代码既麻烦又易于出错，但在没有 finally 的情况下这是必不可少的。不幸的是，在没有 finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。Java 中的 finally 子句解决了这个问题。有了 finally，前面的代码就可以重写为以下的形式：
　　
　　import java.net.*;
　　import java.io.*;
　　
　　class WithFinally
　　{
　　　public void foo2() throws IOException
　　　{
　　　　//在任一个空闲的端口上创建一个套接字
　　　　ServerSocket ss = new ServerSocket(0);
　　　　try {
　　　　　Socket socket = ss.accept();
　　　　　//此处的其他代码...
　　　　}
　　　　finally {
　　　　　ss.close();
　　　　}
　　　}
　　}
　　finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。在第一个示例中提供 catch 块只是为了关闭套接字，现在这是通过 finally 关闭的。假如您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。
　　
　　finally 块必须与 try 或 try/catch 块配合使用。此外，不可能退出 try 块而不执行其 finally 块。假如 finally 块存在，则它总会执行。（无论从那点看，这个陈述都是正确的。有一种方法可以退出 try 块而不执行 finally 块。假如代码在 try 内部执行一条 System.exit(0); 语句，则应用程序终止而不会执行 finally 执行。另一方面，假如您在 try 块执行期间拨掉电源，finally 也不会执行。）
　　
　　try…catch…finally 块
　　最好采用此结构处理异常.在catch中捕捉异常,在finally块中清除不需要的资源,这样程序结构将会更完善,健壮.例如:
　　
　　try{
　　
　　　　　 /**to do */
　　
　　}
　　
　　catch(Exception ex){
　　
　　　　　 System.out.println(ex.getMessage());
　　
　　}
　　
　　finally{
　　
　　　　　 clearUpAll()
　　
　　}
　　
　　3、激发异常
　　Java语言可以不在方法中直接捕捉，而用throw语句将异常抛给上层的调用者。Throw语句就是来明确地抛出一个异常；首先你必需得到一个Throwable的实例句柄，通过参数传到catch中，或者采用new操作符来创建一个。
　　
　　格式：throw new WhcaException(e.getMessage);
　　
　　程序会在throw语句后立即终止，它后面的语句都不执行，然后在包含它的所有try块中从里到外寻找含有与其匹配的catch.
　　
　　声明异常类
　　当throw语句被用在方法说明中时，throw有用throws代替。要害字throws用来标明一个方法可能抛出的各种异常。对大多数Exception子类来说，Java编译器会强迫你声明在一个方法中抛出的异常的类型。如下：
　　
　　格式：type method_name(arg_list) throws WhcaException{
　　
　　　　　　　　　……
　　}
　　
　　例如：public void execute(String str,int index) throws WhcaException{
　　
　　　　　　　　　try{
　　
　　}
　　
　　　　　　　　　catch(Exception e){
　　
　　　　　　　　　　　　 throw new WhcaException(“JB: M:”+e.getMessage);
　　
　　}
　　
　　}
　　
　　4、创建自己的异常类
　　当程序员为提供一些特定的功能用Java类时，往往需要保证类之间有良好的关系，而且类之间的接口易于理解和实现，这是定义一个新的异常类。建议创建自己的异常类，便于维护，治理。
　　
　　定义一个新的异常类
　　　　　 通常采用Exception作为异常类的超类，如：
　　
　　package whca.common;
　　
　　public class WhcaException extends Exception{
　　
　　　　 public WhcaException(){
　　
　　　　 }
　　
　　　　 public WhcaException(String s){
　　
　　　　　　 super(s);
　　
　　　　 }
　　
　　}
　　
　　5、示例
　　下面是示例：TestServlet 调用TestDB和TestPsi，（附代码）假如发生异常怎样最快解决程序发生的异常错误。
　　
　　在整个项目的开发过程中，指定错误代码表，并分类。如PSI类，数据库异常类代码，应用异常类代码，xml异常，网络通讯异常等等；
　　
　　采用自己的异常类，当碰到异常是，激发的异常携带错误类或异常方法的路径：
　　
　　如：setFlag(“PSI001”);
　　
　　throw new WhcaException(“JB:TestA M:exe1 ”+e.getMessage);
　　
　　这里：PSI001为错误代码，“JB:TestA M:exe1”为异常链，e.getMessage为异常信息。
　　
　　例如：碰到错误信息列表为：JB:TestB M:exe2 JB:TestA M:exe1 java.sql.