Java编程思想第4版[中文版](PDF格式)-第74部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
void f（） ＇ // 。。。
它意味着不会从方法里“掷”出违例（除类型为RuntimeException 的违例以外，它可能从任何地方掷出——
稍后还会详细讲述）。
但不能完全依赖违例规范——假若方法造成了一个违例，但没有对其进行控制，编译器会侦测到这个情况，
并告诉我们必须控制违例，或者指出应该从方法里“掷”出一个违例规范。通过坚持从顶部到底部排列违例
规范，Java 可在编译期保证违例的正确性（注释②）。
②：这是在 C＋＋违例控制基础上一个显著的进步，后者除非到运行期，否则不会捕获不符合违例规范的错
误。这使得 C＋＋的违例控制机制显得用处不大。
我们在这个地方可采取欺骗手段：要求“掷”出一个并没有发生的违例。编译器能理解我们的要求，并强迫
使用这个方法的用户当作真的产生了那个违例处理。在实际应用中，可将其作为那个违例的一个“占位符”
使用。这样一来，以后可以方便地产生实际的违例，毋需修改现有的代码。
9。2。4 捕获所有违例
我们可创建一个控制器，令其捕获所有类型的违例。具体的做法是捕获基础类违例类型Exception （也存在
其他类型的基础违例，但Exception 是适用于几乎所有编程活动的基础）。如下所示：
catch（Exception e） ｛
System。out。println（〃caught an exception〃）；
｝
这段代码能捕获任何违例，所以在实际使用时最好将其置于控制器列表的末尾，防止跟随在后面的任何特殊
违例控制器失效。
对于程序员常用的所有违例类来说，由于 Exception 类是它们的基础，所以我们不会获得关于违例太多的信
息，但可调用来自它的基础类Throwable 的方法：
String getMessage（）
获得详细的消息。
String toString（）
返回对Throwable 的一段简要说明，其中包括详细的消息（如果有的话）。
void printStackTrace（）
void printStackTrace（PrintStream）
打印出Throwable 和 Throwable 的调用堆栈路径。调用堆栈显示出将我们带到违例发生地点的方法调用的顺
序。
第一个版本会打印出标准错误，第二个则打印出我们的选择流程。若在Windows 下工作，就不能重定向标准
错误。因此，我们一般愿意使用第二个版本，并将结果送给System。out；这样一来，输出就可重定向到我们
希望的任何路径。
除此以外，我们还可从 Throwable 的基础类Object （所有对象的基础类型）获得另外一些方法。对于违例控
制来说，其中一个可能有用的是getClass（），它的作用是返回一个对象，用它代表这个对象的类。我们可依
次用getName（）或toString（）查询这个Class 类的名字。亦可对 Class 对象进行一些复杂的操作，尽管那些
操作在违例控制中是不必要的。本章稍后还会详细讲述 Class 对象。
下面是一个特殊的例子，它展示了 Exception 方法的使用（若执行该程序遇到困难，请参考第3 章3。1。2 小
节“赋值”）：
//： ExceptionMethods。java
// Demonstrating the Exception Methods
package c09；
public class ExceptionMethods ｛
public static void main（String＇＇ args） ｛
try ｛
266
…………………………………………………………Page 268……………………………………………………………
throw new Exception（〃Here's my Exception〃）；
｝ catch（Exception e） ｛
System。out。println（〃Caught Exception〃）；
System。out。println（
〃e。getMessage（）： 〃 ＋ e。getMessage（））；
System。out。println（
〃e。toString（）： 〃 ＋ e。toString（））；
System。out。println（〃e。printStackTrace（）：〃）；
e。printStackTrace（）；
｝
｝
｝ ///：~
该程序输出如下：
Caught Exception
e。getMessage（）： Here's my Exception
e。toString（）： java。lang。Exception： Here's my Exception
e。printStackTrace（）：
java。lang。Exception： Here's my Exception
at ExceptionMethods。main
可以看到，该方法连续提供了大量信息——每类信息都是前一类信息的一个子集。
9。2 。5 重新“掷”出违例
在某些情况下，我们想重新掷出刚才产生过的违例，特别是在用Exception 捕获所有可能的违例时。由于我
们已拥有当前违例的句柄，所以只需简单地重新掷出那个句柄即可。下面是一个例子：
catch（Exception e） ｛
System。out。println（〃一个违例已经产生〃）；
throw e；
｝
重新“掷”出一个违例导致违例进入更高一级环境的违例控制器中。用于同一个 try 块的任何更进一步的
catch 从句仍然会被忽略。此外，与违例对象有关的所有东西都会得到保留，所以用于捕获特定违例类型的
更高一级的控制器可以从那个对象里提取出所有信息。
若只是简单地重新掷出当前违例，我们打印出来的、与printStackTrace（）内的那个违例有关的信息会与违
例的起源地对应，而不是与重新掷出它的地点对应。若想安装新的堆栈跟踪信息，可调用
fillInStackTrace（），它会返回一个特殊的违例对象。这个违例的创建过程如下：将当前堆栈的信息填充到
原来的违例对象里。下面列出它的形式：
//： Rethrowing。java
// Demonstrating fillInStackTrace（）
public class Rethrowing ｛
public static void f（） throws Exception ｛
System。out。println（
〃originating the exception in f（）〃）；
throw new Exception（〃thrown from f（）〃）；
｝
public static void g（） throws Throwable ｛
try ｛
f（）；
｝ catch（Exception e） ｛
267
…………………………………………………………Page 269……………………………………………………………
System。out。println（
〃Inside g（）； e。printStackTrace（）〃）；
e。printStackTrace（）；
throw e； // 17
// throw e。fillInStackTrace（）； // 18
｝
｝
public static void
main（String＇＇ args） throws Throwable ｛
try ｛
g（）；
｝ catch（Exception e） ｛
System。out。println（
〃Caught in main； e。printStackTrace（）〃）；
e。printStackTrace（）；
｝
｝
｝ ///：~
其中最重要的行号在注释内标记出来。注意第 17行没有设为注释行。它的输出结果如下：
originating the exception in f（）
Inside g（）； e。printStackTrace（）
java。lang。Exception： thrown from f（）
at Rethrowing。f（Rethrowing。java：8）
at Rethrowing。g（Rethrowing。java：12）
at Rethrowing。main（Rethrowing。java：24）
Caught in main； e。printStackTrace（）
java。lang。Exception： thrown from f（）
at Rethrowing。f（Rethrowing。java：8）
at Rethrowing。g（Rethrowing。java：12）
at Rethrowing。main（Rethrowing。java：24）
因此，违例堆栈路径无论如何都会记住它的真正起点，无论自己被重复“掷”了好几次。
若将第 17 行标注（变成注释行），而撤消对第 18 行的标注，就会换用fillInStackTrace（），结果如下：
originating the exception in f（）
Inside g（）； e。printStackTrace（）
java。lang。Exception： thrown from f（）
at Rethrowing。f（Rethrowing。java：8）
at Rethrowing。g（Rethrowing。java：12）
at Rethrowing。main（Rethrowing。java：24）
Caught in main； e。printStackTrace（）
java。lang。Exception： thrown from f（）
at Rethrowing。g（Rethrowing。java：18）
at Rethrowing。main（Rethrowing。java：24）
由于使用的是fillInStackTrace（） ，第18 行成为违例的新起点。
针对 g（）和 main（），Throwable 类必须在违例规格中出现，因为fillInStackTrace（）会生成一个 Throwable
对象的句柄。由于 Throwable 是 Exception 的一个基础类，所以有可能获得一个能够“掷”出的对象（具有
Throwable 属性），但却并非一个 Exception （违例）。因此，在main（）中用于Exception 的句柄可能丢失
自己的目标。为保证所有东西均井然有序，编译器强制Throwable 使用一个违例规范。举个例子来说，下述
268
…………………………………………………………Page 270……………………………………………………………
程序的违例便不会在main（）中被捕获到：
//： ThrowOut。java
public class ThrowOut ｛
public static void
main（String＇＇ args） throws Throwable ｛
try ｛
throw new Throwable（）；
｝ catch（Exception e） ｛
System。out。println（〃Caught in main（）〃）；
｝
｝
｝ ///：~
也有可能从一个已经捕获的违例重新“掷”出一个不同的违例。但假如这样做，会得到与使用
fillInStackTrace（）类似的效果：与违例起源地有关的信息会全部丢失，我们留下的是与新的 throw 有关的
信息。如下所示：
//： RethrowNew。java
// Rethrow a different object from the one that
// was caught
public class RethrowNew ｛
public static void f（） throws Exception ｛
System。out。println（
〃originating the exception in f（）〃）；
throw new Exception（〃thrown from f（）〃）；
｝
public static void main（String＇＇ args） ｛
try ｛
f（）；
｝ catch（Exception e） ｛
System。out。println（
〃Caught in main； e。printStackTrace（）〃）；
e。printStackTrace（）；
throw new NullPointerException（〃from main〃）；
｝
｝
｝ ///：~
输出如下：
originating the exception in f（）
Caught in main； e。printStackTrace（）
java。lang。Exception： thrown from f（）
at RethrowNew。f（RethrowNew。java：8）
at RethrowNew。main（RethrowNew。java：13）
java。lang。NullPointerException： from main
at RethrowNew。main（RethrowNew。java：18）
最后一个违例只知道自己来自main（），而非来自 f（）。注意Throwable 在任何违例规范中都不是必需的。
269
…………………………………………………………Page 271……………………………………………………………
永远不必关心如何清除前一个违例，或者与之有关的其他任何违例。它们都属于用new 创建的、以内存堆为
基础的对象，所以垃圾收集器会自动将其清除。
9。3 标准 Java 违例
Java 包含了一个名为Throwable 的类，它对可以作为违例“掷”出的所有东西进行了描述。Throwable 对象
有两种常规类型（亦即“从Throwable 继承”）。其中，Error 代表编译期和系统错误，我们一般不必特意
捕获它们（除在特殊情况以外）。Exception 是可以从任何标准 Java 库的类方法中“掷”出的基本类型。此
外，它们亦可从我们自己的方法以及运行期偶发事件中“掷”出。
为获得违例的一个综合概念，最好的方法是阅读由 http：//java。sun。 提供的联机 Java 文档（当然，首先
下载它们更好）。为了对各种违例有一个大概的印象，这个工作是相当有价值的。但大家不久就会发现，除
名字外，一个违例和下一个违例之间并不存在任何特殊的地方。此外，Java 提供的违例数量正在日益增多；
从本质上说，把它们印到一本书里是没有意义的。大家从其他地方获得的任何新库可能也提供了它们自己的
违例。我们最需要掌握的是基本概念，以及用这些违例能够做什么。
java。lang。Exception
这是程序能捕获的基本违例。其他违例都是从它衍生出去的。这里要注意的是违例的名字代表发生的问题，
而且违例名通常都是精心挑�
