Java
异常处理
异常处理
●
概念
●
异常处理
●
激发异常
●
创建自己的异常
●
示例
Java
语言的设计从根本上便于我们写出整洁、设计良好的代码；尽管如此，在程序运行中仍可能有各种各样的错误出现。
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);
}
}