Java编程思想第4版[中文版](PDF格式)-第70部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！


　　　　　　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　代替了。　　

这是一项相当严重的缺陷，因为它意味着一个违例可能完全丢失。而且就象前例演示的那样，这种丢失显得　

非常“自然”，很难被人查出蛛丝马迹。而与此相反，C＋＋里如果第二个违例在第一个违例得到控制前产生，　

就会被当作一个严重的编程错误处理。或许Java　以后的版本会纠正这个问题（上述结果是用Java　1。1　生成　

的）。　　



9。7　构建器　　



为违例编写代码时，我们经常要解决的一个问题是：“一旦产生违例，会正确地进行清除吗？”大多数时候　

都会非常安全，但在构建器中却是一个大问题。构建器将对象置于一个安全的起始状态，但它可能执行一些　

操作——如打开一个文件。除非用户完成对象的使用，并调用一个特殊的清除方法，否则那些操作不会得到　

正确的清除。若从一个构建器内部“掷”出一个违例，这些清除行为也可能不会正确地发生。所有这些都意　

味着在编写构建器时，我们必须特别加以留意。　　

由于前面刚学了finally，所以大家可能认为它是一种合适的方案。但事情并没有这么简单，因为　finally　

每次都会执行清除代码——即使我们在清除方法运行之前不想执行清除代码。因此，假如真的用　finally进　

行清除，必须在构建器正常结束时设置某种形式的标志。而且只要设置了标志，就不要执行　finally　块内的　

任何东西。由于这种做法并不完美　（需要将一个地方的代码同另一个地方的结合起来），所以除非特别需　

要，否则一般不要尝试在finally　中进行这种形式的清除。　　

在下面这个例子里，我们创建了一个名为　InputFile　的类。它的作用是打开一个文件，然后每次读取它的一　

行内容（转换为一个字串）。它利用了由　Java　标准　IO　库提供的FileReader　以及BufferedReader　类（将于　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　280　


…………………………………………………………Page　282……………………………………………………………

第　10　章讨论）。这两个类都非常简单，大家现在可以毫无困难地掌握它们的基本用法：　　

　　

//：　Cleanup。java　　

//　Paying　attention　to　exceptions　　

//　in　constructors　　

import　java。io。*；　　

　　

class　InputFile　｛　　

　　private　BufferedReader　in；　　

　　InputFile（String　fname）　throws　Exception　｛　　

　　　　try　｛　　

　　　　　　in　=　　　

　　　　　　　　new　BufferedReader（　　

　　　　　　　　　　new　FileReader（fname））；　　

　　　　　　//　Other　code　that　might　throw　exceptions　　

　　　　｝　catch（FileNotFoundException　e）　｛　　

　　　　　　System。out。println（　　

　　　　　　　　〃Could　not　open　〃　＋　fname）；　　

　　　　　　//　Wasn't　open；　so　don't　close　it　　

　　　　　　throw　e；　　

　　　　｝　catch（Exception　e）　｛　　

　　　　　　//　All　other　exceptions　must　close　it　　

　　　　　　try　｛　　

　　　　　　　　in。close（）；　　

　　　　　　｝　catch（IOException　e2）　｛　　

　　　　　　　　System。out。println（　　

　　　　　　　　　　〃in。close（）　unsuccessful〃）；　　

　　　　　　｝　　

　　　　　　throw　e；　　

　　　　｝　finally　｛　　

　　　　　　//　Don't　close　it　here！！！　　

　　　　｝　　

　　｝　　

　　String　getLine（）　｛　　

　　　　String　s；　　

　　　　try　｛　　

　　　　　　s　=　in。readLine（）；　　

　　　　｝　catch（IOException　e）　｛　　

　　　　　　System。out。println（　　

　　　　　　　　〃readLine（）　unsuccessful〃）；　　

　　　　　　s　=　〃failed〃；　　

　　　　｝　　

　　　　return　s；　　

　　｝　　

　　void　cleanup（）　｛　　

　　　　try　｛　　

　　　　　　in。close（）；　　

　　　　｝　catch（IOException　e2）　｛　　

　　　　　　System。out。println（　　

　　　　　　　　〃in。close（）　unsuccessful〃）；　　

　　　　｝　　

　　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　281　


…………………………………………………………Page　283……………………………………………………………

｝　　

　　

public　class　Cleanup　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　try　｛　　

　　　　　　InputFile　in　=　　　

　　　　　　　　new　InputFile（〃Cleanup。java〃）；　　

　　　　　　String　s；　　

　　　　　　int　i　=　1；　　

　　　　　　while（（s　=　in。getLine（））　！=　null）　　

　　　　　　　　System。out。println（〃〃＋　i＋＋　＋　〃：　〃　＋　s）；　　

　　　　　　in。cleanup（）；　　

　　　　｝　catch（Exception　e）　｛　　

　　　　　　System。out。println（　　

　　　　　　　　〃Caught　in　main；　e。printStackTrace（）〃）；　　

　　　　　　e。printStackTrace（）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

该例使用了　Java　1。1　IO　类。　　

用于　InputFile　的构建器采用了一个String　（字串）参数，它代表我们想打开的那个文件的名字。在一个　

try　块内部，它用该文件名创建了一个　FileReader。对FileReader　来说，除非转移并用它创建一个能够实际　

与之“交谈”的BufferedReader，否则便没什么用处。注意InputFile　的一个好处就是它同时合并了这两种　

行动。　　

若FileReader　构建器不成功，就会产生一个　FileNotFoundException　（文件未找到违例）。必须单独捕获这　

个违例——这属于我们不想关闭文件的一种特殊情况，因为文件尚未成功打开。其他任何捕获从句（catch）　

都必须关闭文件，因为文件已在进入那些捕获从句时打开（当然，如果多个方法都能产生一个　

FileNotFoundException　违例，就需要稍微用一些技巧。此时，我们可将不同的情况分隔到数个try　块　

内）。close（）方法会掷出一个尝试过的违例。即使它在另一个catch　从句的代码块内，该违例也会得以捕　

获——对Java　编译器来说，那个　catch　从句不过是另一对花括号而已。执行完本地操作后，违例会被重新　

　“掷”出。这样做是必要的，因为这个构建器的执行已经失败，我们不希望调用方法来假设对象已正确创建　

以及有效。　　

在这个例子中，没有采用前述的标志技术，finally　从句显然不是关闭文件的正确地方，因为这可能在每次　

构建器结束的时候关闭它。由于我们希望文件在　InputFile　对象处于活动状态时一直保持打开状态，所以这　

样做并不恰当。　　

getLine（）方法会返回一个字串，其中包含了文件中下一行的内容。它调用了readLine（），后者可能产生一　

个违例，但那个违例会被捕获，使　getLine（）不会再产生任何违例。对违例来说，一项特别的设计问题是决　

定在这一级完全控制一个违例，还是进行部分控制，并传递相同（或不同）的违例，或者只是简单地传递　

它。在适当的时候，简单地传递可极大简化我们的编码工作。getLine（）方法会变成：　　

String　getLine（）　throws　IOException　｛　　

return　in。readLine（）；　　

｝　　

但是当然，调用者现在需要对可能产生的任何　IOException进行控制。　　

用户使用完毕　InputFile　对象后，必须调用　cleanup（）方法，以便释放由　BufferedReader　以及／或者　

FileReader　占用的系统资源（如文件句柄）——注释⑥。除非　InputFile　对象使用完毕，而且到了需要弃之　

不用的时候，否则不应进行清除。大家可能想把这样的机制置入一个　finalize（）方法内，但正如第　4　章指出　

的那样，并非总能保证　finalize（）获得正确的调用（即便确定它会调用，也不知道何时开始）。这属于　Java　

的一项缺陷——除内存清除之外的所有清除都不会自动进行，所以必须知会客户程序员，告诉他们有责任用　

finalize（）保证清除工作的正确进行。　　

　　

⑥：在　C＋＋里，“破坏器”可帮我们控制这一局面。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　282　


…………………………………………………………Page　284……………………………………………………………

　　

在Cleanup。java　中，我们创建了一个InputFile，用它打开用于创建程序的相同的源文件。同时一次读取该　

文件的一行内容，而且添加相应的行号。所有违例都会在　main（）中被捕获——尽管我们可选择更大的可靠　

性。　　

这个示例也向大家展示了为何在本书的这个地方引入违例的概念。违例与　Java　的编程具有很高的集成度，这　

主要是由于编译器会强制它们。只有知道了如何操作那些违例，才可更进一步地掌握编译器的知识。　　



9。8　违例匹配　　



　“掷”出一个违例后，违例控制系统会按当初编写的顺序搜索“最接近”的控制器。一旦找到相符的控制　

器，就认为违例已得到控制，不再进行更多的搜索工作。　　

在违例和它的控制器之间，并不需要非常精确的匹配。一个衍生类对象可与基础类的一个控制器相配，如下　

例所示：　　

　　

//：　Human。java　　

//　Catching　Exception　Hierarchies　　

　　

class　Annoyance　extends　Exception　｛｝　　

class　Sneeze　extends　Annoyance　｛｝　　

　　

public　class　Human　｛　　

　　public　static　void　main（String　＇＇　args）　｛　　

　　　　try　｛　　

　　　　　　throw　new　Sneeze（）；　　

　　　　｝　catch（Sneeze　s）　｛　　

　　　　　　System。out。println（〃Caught　Sneeze〃）；　　

　　　　｝　catch（Annoyance　a）　｛　　

　　　　　　System。out。println（〃Caught　Annoyance〃）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

Sneeze　违例会被相符的第一个　catch　从句捕获。当然，这只是第一个。然而，假如我们删除第一个　catch　从　

句：　　

　　

　　　　try　｛　　

　　　　　　throw　new　Sneeze（）；　　

　　　　｝　catch（Annoyance　a）　｛　　

　　　　　　System。out。println（〃Caught　Annoyance〃）；　　

　　　　｝　　

　　

那么剩下的　catch　从句依然能够工作，因为它捕获的是　Sneeze　的基础类。换言之，catch（Annoyance　e）能捕　

获一个Annoyance　以及从它衍生的任何类。这一点非常重要，因为一旦我们决定为一个方法添加更多的违　

例，而且它们都是从相同的基础类继承的，那么客户程序员的代码就不需要更改。至少能够假定它们捕获的　

是基础类。　　

若将基础类捕获从句置于第一位，试图“屏蔽”衍生类违例，就象下面这样：　　

　　

　　　　try　｛　　

　　　　　　throw　new　Sneeze（）；　　

　　　　｝　catch（Annoyance　a）　｛　　

　　　　　　System。out。println