当程序出现错误时,系统会自动抛出异常:除此之外,Java 也允许程序自行抛出异常,自行抛出异常使用 throw 语句来完成(注意此处的 throw 没有后面的 s,与前面声明抛出的 throws 是有区别的)。
1,抛出异常
异常是一种很“主观”的说法,以下雨为例,假设大家约好明天去爬山郊游,如果第二天下雨了,这种情况会打破既定计划,就属于一种异常:但对于正在期盼天降甘霖的农民而言,如果第二天下雨了,他们正好随雨追肥,这就完全正常。
很多时候,系统是否要抛出异常,可能需要根据应用的业务需求来决定,如果程序中的数据、执行与既定的业务需求不符,这就是一种异常。由于与业务需求不符而产生的异常,必须由程序员来决定抛出,系统无法抛出这种异常。
如果需要在程序中自行抛出异常,则应使用 throw 语句,throw 语句可以单独使用,throw 语句抛出的不是异常类,而是一个异常实例,而且每次只能抛出一个异常实例。throw 语句的语法格式如下:
throw ExceptionInstance
可以利用 throw 语句再次改写前面五子棋游戏中处理用户输入的代码:
try
{
//将用户输入的字符串以逗号(,)作为分隔符,分隔成两个字符串
//将两个字符串转换成用户下棋的坐标
int xPos = Integer.parseInt(posStrArr[0]);
int yPos = Integer.parseInt(posStrArr[1]);
//如果用户试图下棋的坐标点已经有棋了,程序自行抛出异常
if (!gb.board[xPos - 1][yPos - 1].equalst("+"))
{
throw new Exception("您试图下棋的坐标点已经有棋了");//1
}
//把对应的数组元素赋为"·"
gb.board[xPos - 1][yPost - 1] = "·"
}
catch (Exception e)
{
System.out.println("您输入的坐标不合法,请重新输入,下棋坐标应为x,y的格式:");
continue;
}
上面程序中 1 代码使用 throw 语句来自行抛出异常,程序认为当用户试图向一个已有棋子的坐标点下棋就是异常。当 Java 运行时接收到用户自行抛出的异常时,同样会中止当前的执行流,跳到该异常对应的 catch 块,由该 catch 块来处理该异常。也就是说,不管是系统自动抛出的异常,还是程序员手动抛出的异常,Java 运行时环境对异常的处理没有任何差别。
如果 throw 语句抛出的异常是 Checked 异常,则该 throw 语句要么处于 try 块里,显式捕获该异常,要么放在一个带 throws 声明抛出的方法中,即把该异常交给该方法的调用者处理:如果 throw 语句抛出的异常是 Runtime 异常,则该语句无须放在 try 块里,也无须放在带 throws 声明抛出的方法中;程序既可以显式使用 try...catch 来捕获并处理该异常,也可以完全不理会该异常,把该异常交给该方法调用者处理。例如下面例子程序。
package com.sym.demo5;
public class ThrowTest {
public static void main(String[] args) {
try {
// 调用声明抛出 Checked 异常的方法,要么显式捕获该异常
// 要么在 main 方法中再次声明抛出
throwChecked(-3);
} catch (Exception e) {
System.out.println(e.getMessage());
}
// 调用声明抛出 Runtime 异常的方法既可以显式捕获该异常
// 也可不理会该异常
throwRuntime(3);
}
public static void throwChecked(int a) throws Exception{
if (a > 0){
//自行抛出 Exception 异常
//该代码必须处于 try 块里,或处于带 throws 声明的方法中
throw new Exception("a 的值大于 0,不符合要求");
}
}
public static void throwRuntime(int a){
if( a > 0) {
// 自行抛出 RuntimeException 异常,既可以显式捕获该异常
// 也可完全不理会该异常,把该异常交给该方法调用者处理
throw new RuntimeException("a 的值大于 0,不符合要求");
}
}
}
通过上面程序也可以看出,自行抛出 Runtime 异常比自行抛出 Checked 异常的灵活性更好。同样,抛出 Checked 异常则可以让编译器提醒程序员必须处理该异常。
2,自定义异常类
在通常情况下,程序很少会自行抛出系统异常,因为异常的类名通常也包含了该异常的有用信息。所以在选择抛出异常时,应该选择合适的异常类,从而可以明确地描述该异常情况。在这种情形下.应用程序常常需要抛出自定义异常。
用户自定义异常都应该继承 Exception 基类,如果希望自定义 Runtime 异常,则应该继承 RuntimeException 基类。定义异常类时通常需要提供两个构造器:一个是无参数的构造器;另一个是带一个字符串参数的构造器,这个字符串将作为该异常对象的描述信息(也就是异常对象的 getMessage() 方法的返回值)。
下面例子程序创建了一个自定义异常类。
package com.sym.demo5;
public class AuctionException extends Exception {
//无参数的构造器
public AuctionException(){}//1
//带一个字符串参数的构造器
public AuctionException(String msg){//2
super(msg);
}
}
上面程序创建了 AuctionException 异常类,并为该异常类提供了两个构造器。尤其是②号代码部分创建的带一个字符串参数的构造器,其执行体也非常简单,仅通过 super 来调用父类的构造器,正是这行 super 调用可以将此字符串参数传给异常对象的 message 属性,该 message 属性就是该异常对象的详细描述信息。
如果需要白定义 Runtime 异常,只需将 AuctionException.java 程序中的 Exception 基类改为 RuntimeException 基类,其他地方无须修改。
在大部分情况下,创建自定义异常都可采用与 AuctionException.java 相似的代码完成只需改变 AuctionException 异常的类名即可,让该异常类的类名可以准确描述该异常。
3,catch 和 throw 同时使用
前面介绍的异常处理方式有如下两种。
在出现异常的方法内捕获并处理异常,该方法的调用者将不能再次捕获该异常。
该方法签名中声明抛出该异常,将该异常完全交给方法调用者处理。
在实际应用中往往需要更复杂的处理方式——当一个异常出现时,单靠某个方法无法完全处理该异常,必须由几个方法协作才可完全处理该异常。也就是说,在异常出现的当前方法中,程序只对异常进行部分处理,还有些处理需要在该方法的调用者中才能完成,所以应该再次抛出异常,让该方法的调用者也能捕获到异常。
为了实现这种通过多个方法协作处理同一个异常的情形,可以在 catch 块中结合 throw 语句来完成。如下例子程序示范了这种 catch 和 throw 同时使用的方法。
public class AuctionTest
{
private double initPrice = 30.0;
// 因为该方法中显式抛出了AuctionException异常,
// 所以此处需要声明抛出AuctionException异常
public void bid(String bidPrice)
throws AuctionException
{
double d = 0.0;
try
{
d = Double.parseDouble(bidPrice);
}
catch (Exception e)
{
// 此处完成本方法中可以对异常执行的修复处理,
// 此处仅仅是在控制台打印异常跟踪栈信息。
e.printStackTrace();
//再次抛出自定义异常
throw new AuctionException("竞拍价必须是数值,"
+ "不能包含其他字符!");
}
if (initPrice > d)
{
throw new AuctionException("竞拍价比起拍价低,"
+ "不允许竞拍!");
}
initPrice = d;
}
public static void main(String[] args)
{
AuctionTest at = new AuctionTest();
try
{
at.bid("df");
}
catch (AuctionException ae)
{
// 再次捕捉到bid方法中的异常。并对该异常进行处理
System.err.println(ae.getMessage());
}
}
}
上面程序中 bid() 方法代码对应的 catch 块捕获到异常后,系统打印了该异常的跟踪栈信息,接着抛出一个 AuctionException 异常,通知该方法的调用者再次处理该 AuctionException 异常。所以程序中的 main 方法,也就是 bid() 方法调用者还可以再次捕获 AuctionException 异常,并将该异常的详细描述信息输出到标准错误输出。
这种 catch 和 throw 结合使用的情况在大型企业级应用中非常常用。企业级应用对异常的处理通常分成两个部分:① 应用后台需要通过日志来记录异常发生的详细情况;② 应用还需要根据异常向应用使用者传达某种提示。在这种情形下,所有异常都需要两个方法共同完成,也就必须将 catch 和 throw 结合使用。
4,Java 7 增强的 throw 语句
对应如下代码:
try
{
new FileOutputStream("a.txt");
}
catch (Exception ex)
{
ex.printStackTrace();
throw ex;//1
}
上面代码片段中的 1 代码处再次抛出了捕获到的异常,但这个 ex 对象的情况比较特殊:程序捕获该异常时,声明该异常的类型为 Exception;但实际上 try 块中可能只调用了 FileOutputStream 构造器,这个构造器声明只是抛出了 FileNotFoundException 异常。
在 Java 7 以前,Java 编译器的处理“简单而粗暴”——由于在捕获该异常时声明 ex 的类型是 Exception,因此 Java 编译器认为这段代码可能抛出 Exception 异常,所以包含这段代码的方法通常需要声明抛出 Exception 异常。例如如下方法。
public class ThrowTest2
{
public static void main(String[] args)
// Java 6认为①号代码可能抛出Exception,
// 所以此处声明抛出Exception
throws Exception
{
try
{
new FileOutputStream("a.txt");
}
catch (Exception ex)
{
ex.printStackTrace();
throw ex; //①
}
}
}
从 Java 7 开始.Java 编译器会执行更细致的检查,Java 编译器会检查 throw 语句抛出异常的实际类型,这样编译器知道①号代码处实际上只可能抛出 FileNotFoundException 异常,因此在方法签名中只要声明抛出 FileNotFoundException 异常即可。即可以将代码改为如下形式(程序清单同上)。
public class ThrowTest2
{
public static void main(String[] args)
// Java 7会检查①号代码可能抛出异常的实际类型,
// 因此此处只需声明抛出FileNotFoundException即可。
throws FileNotFoundException
{
try
{
new FileOutputStream("a.txt");
}
catch (Exception ex)
{
ex.printStackTrace();
throw ex; //①
}
}
}
5,异常链
对于真实的企业级应用而言,常常有严格的分层关系,层与层之间有非常清晰的划分,上层功能的实现严格依赖于下层的 API,也不会跨层访问。图 10.5 显示了这种具有分层结构应用的大致示意图。
对于一个采用图 10.5 所示结构的应用,当业务逻辑层访问持久层出现 SQLException 异常时,程序不应该把底层的 SQLExccption 异常传到用户界面,有如下两个原因。
对于正常用户而言,他们不想看到底层 SQLException 异常,SQLExccption 异常对他们使用该系统没有任何帮助。
对于恶意用户而言,将 SQLException 异常暴露出来不安全。
把底层的原始异常直接传给用户是一种不负责任的表现.通常的做法是:程序先捕获原始异常,然后抛出一个新的业务异常,新的业务异常中包含了对用户的提示信息,这种处理方式被称为异常转译。假设程序需要实现工资计算的方法,则程序应该采用如下结构的代码来实现该方法。
public calSal() throws SalException
{
try
{
//实现结算工资的业务逻辑
...
}
catch(SQLException sqle)
{
// 把原始异常记录下来,留给管理员
...
// 下面异常中的 message 就是对用户的提示
throw new SalException("访问底层数据库出现异常");
}
catch (Exception e)
{
// 把原始异常记录下来,留给管理员
...
// 下面异常中的 message 就是对用户的提示
throw new SalException("系统出现未知异常");
}
}
这种把原始异常信息隐藏起来,仅向上提供必要的异常提示信息的处理方式,可以保证底层异常不会扩散到表现层,可以避免向上暴露太多的实现细节,这完全符合面向对象的封装原则。
这种把捕获一个异常然后接着抛出另一个异常,井把原始异常信息保存下来是一种典型的链式处理(23种设计模式之一:职责链模式),也被称为“异常链”。
在 JDK l.4 以前,程序员必须自己编写代码来保持原始异常信息。从 JDK l.4 以后,所有 Throwable 的子类在构造器中都可以接收一个 cause 对象作为参数。这个 cause 就用来表示原始异常,这样可以把原始异常传递给新的异常,使得即使在当前位置创建并抛出了新的异常,你也能通过这个异常链追踪到异常最初发生的位置。如果我们希望上面的 SalException 可以追踪到最原始的异常信息,则可以将该方法改写为如下形式。
public calSal() throws SalException
{
try
{
//实现结算工资的业务逻辑
...
}
catch(SQLException sqle)
{
// 把原始异常记录下来,留给管理员
...
// 下面异常中的 message 就是对用户的提示
throw new SalException(sqle);
}
catch (Exception e)
{
// 把原始异常记录下来,留给管理员
...
// 下面异常中的 message 就是对用户的提示
throw new SalException(e);
}
}
上面程序中代码创建 SaIException 对象时,传人了一个 Exception 对象,而不是传入了一个 String 对象,这就需要 SaIException 类有相应的构造器。从 JDK l.4 以后,Throwable 基类已有了一个可以接收 Exception 参数的方法,所以可以采用如下代码来定义 SalException 类。
<span style="font-size: 12px;">public class SalException extends Exception
{
public SalException(){}
public SalException(String msg)
{
super(msg);
}
//创建一个可以接受Throwable参数的构造器
public SalException(Throwable t)
{
super(t);
}
}</span>
创建了这个 SalException 业务异常类后,就可以用它来封装原始异常,从而实现对异常的链式处理。