按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
实。若将自己的try 块置入一个循环内，就可建立一个条件，它必须在继续程序之前满足。亦可添加一个
static计数器或者另一些设备，允许循环在放弃以前尝试数种不同的方法。这样一来，我们的程序可以变得
更加“健壮”。
输出如下：
Exception thrown
in finally clause
No exception
in finally clause
无论是否“掷”出一个违例，finally 从句都会执行。
9。6。1 用 finally 做什么
在没有“垃圾收集”以及“自动调用破坏器”机制的一种语言中（注释⑤），finally 显得特别重要，因为
程序员可用它担保内存的正确释放——无论在 try 块内部发生了什么状况。但Java 提供了垃圾收集机制，所
以内存的释放几乎绝对不会成为问题。另外，它也没有构建器可供调用。既然如此，Java 里何时才会用到
finally 呢？
⑤：“破坏器”（Destructor）是“构建器”（Constructor）的反义词。它代表一个特殊的函数，一旦某个
对象失去用处，通常就会调用它。我们肯定知道在哪里以及何时调用破坏器。C＋＋提供了自动的破坏器调用机
制，但Delphi 的Object Pascal 版本 1及 2 却不具备这一能力（在这种语言中，破坏器的含义与用法都发生
了变化）。
除将内存设回原始状态以外，若要设置另一些东西，finally 就是必需的。例如，我们有时需要打开一个文
件或者建立一个网络连接，或者在屏幕上画一些东西，甚至设置外部世界的一个开关，等等。如下例所示：
//： OnOffSwitch。java
// Why use finally？
class Switch ｛
boolean state = false；
boolean read（） ｛ return state； ｝
void on（） ｛ state = true； ｝
void off（） ｛ state = false； ｝
｝
277
…………………………………………………………Page 279……………………………………………………………
public class OnOffSwitch ｛
static Switch sw = new Switch（）；
public static void main（String＇＇ args） ｛
try ｛
sw。on（）；
// Code that can throw exceptions。。。
sw。off（）；
｝ catch（NullPointerException e） ｛
System。out。println（〃NullPointerException〃）；
sw。off（）；
｝ catch（IllegalArgumentException e） ｛
System。out。println（〃IOException〃）；
sw。off（）；
｝
｝
｝ ///：~
这里的目标是保证main（）完成时开关处于关闭状态，所以将 sw。off（）置于 try 块以及每个违例控制器的末
尾。但产生的一个违例有可能不是在这里捕获的，这便会错过 sw。off（）。然而，利用finally，我们可以将
来自 try 块的关闭代码只置于一个地方：
//： WithFinally。java
// Finally Guarantees cleanup
class Switch2 ｛
boolean state = false；
boolean read（） ｛ return state； ｝
void on（） ｛ state = true； ｝
void off（） ｛ state = false； ｝
｝
public class WithFinally ｛
static Switch2 sw = new Switch2（）；
public static void main（String＇＇ args） ｛
try ｛
sw。on（）；
// Code that can throw exceptions。。。
｝ catch（NullPointerException e） ｛
System。out。println（〃NullPointerException〃）；
｝ catch（IllegalArgumentException e） ｛
System。out。println（〃IOException〃）；
｝ finally ｛
sw。off（）；
｝
｝
｝ ///：~
在这儿，sw。off（）已移至一个地方。无论发生什么事情，都肯定会运行它。
即使违例不在当前的catch 从句集里捕获，finally 都会在违例控制机制转到更高级别搜索一个控制器之前
得以执行。如下所示：
278
…………………………………………………………Page 280……………………………………………………………
//： AlwaysFinally。java
// Finally is always executed
class Ex extends Exception ｛｝
public class AlwaysFinally ｛
public static void main（String＇＇ args） ｛
System。out。println（
〃Entering first try block〃）；
try ｛
System。out。println（
〃Entering second try block〃）；
try ｛
throw new Ex（）；
｝ finally ｛
System。out。println（
〃finally in 2nd try block〃）；
｝
｝ catch（Ex e） ｛
System。out。println（
〃Caught Ex in first try block〃）；
｝ finally ｛
System。out。println（
〃finally in 1st try block〃）；
｝
｝
｝ ///：~
该程序的输出展示了具体发生的事情：
Entering first try block
Entering second try block
finally in 2nd try block
Caught Ex in first try block
finally in 1st try block
若调用了break 和 continue 语句，finally 语句也会得以执行。请注意，与作上标签的break 和 continue
一道，finally排除了 Java 对 goto 跳转语句的需求。
9。6。2 缺点：丢失的违例
一般情况下，Java 的违例实施方案都显得十分出色。不幸的是，它依然存在一个缺点。尽管违例指出程序里
存在一个危机，而且绝不应忽略，但一个违例仍有可能简单地“丢失”。在采用 finally 从句的一种特殊配
置下，便有可能发生这种情况：
//： LostMessage。java
// How an exception can be lost
class VeryImportantException extends Exception ｛
public String toString（） ｛
return 〃A very important exception！〃；
｝
279
…………………………………………………………Page 281……………………………………………………………
｝
class HoHumException extends Exception ｛
public String toString（） ｛
return 〃A trivial exception〃；
｝
｝
public class LostMessage ｛
void f（） throws VeryImportantException ｛
throw new VeryImportantException（）；
｝
void dispose（） throws HoHumException ｛
throw new HoHumException（）；
｝
public static void main（String＇＇ args）
throws Exception ｛
LostMessage lm = new LostMessage（）；
try ｛
lm。f（）；
｝ finally ｛
lm。dispose（）；
｝
｝
｝ ///：~
输出如下：
A trivial exception
at LostMessage。dispose（LostMessage。java：21）
at LostMessage。main（LostMessage。java：29）
可以看到，这里不存在 VeryImportantException （非常重要的违例）的迹象，它只是简单地被finally从句
中的HoHumException 代替了。
这是一项相当严重的缺陷，因为它意味着一个违例可能完全丢失。而且就象前例�