友情提示：如果本网页打开太慢或显示不完整，请尝试鼠标右键“刷新”本网页！
Java编程思想第4版[中文版](PDF格式)-第68部分
快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！
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
这是程序能捕获的基本违例。其他违例都是从它衍生出去的。这里要注意的是违例的名字代表发生的问题，
而且违例名通常都是精心挑选的，可以很清楚地说明到底发生了什么事情。违例并不全是在 java。lang 中定
义的；有些是为了提供对其他库的支持，如util，net 以及io等——我们可以从它们的完整类名中看出这一
点，或者观察它们从什么继承。例如，所有IO违例都是从 java。io。IOException 继承的。
9。3。1 RuntimeException 的特殊情况
本章的第一个例子是：
if（t == null）
throw new NullPointerException（）；
看起来似乎在传递进入一个方法的每个句柄中都必须检查 null （因为不知道调用者是否已传递了一个有效的
句柄），这无疑是相当可怕的。但幸运的是，我们根本不必这样做——它属于 Java 进行的标准运行期检查的
一部分。若对一个空句柄发出了调用，Java 会自动产生一个NullPointerException 违例。所以上述代码在
任何情况下都是多余的。
这个类别里含有一系列违例类型。它们全部由 Java 自动生成，毋需我们亲自动手把它们包含到自己的违例规
范里。最方便的是，通过将它们置入单独一个名为 RuntimeException 的基础类下面，它们全部组合到一起。
这是一个很好的继承例子：它建立了一系列具有某种共通性的类型，都具有某些共通的特征与行为。此外，
我们没必要专门写一个违例规范，指出一个方法可能会“掷”出一个 RuntimeException，因为已经假定可能
出现那种情况。由于它们用于指出编程中的错误，所以几乎永远不必专门捕获一个“运行期违例”——
RuntimeException——它在默认情况下会自动得到处理。若必须检查 RuntimeException，我们的代码就会变
得相当繁复。在我们自己的包里，可选择“掷”出一部分 RuntimeException。
如果不捕获这些违例，又会出现什么情况呢？由于编译器并不强制违例规范捕获它们，所以假如不捕获的
话，一个RuntimeException 可能过滤掉我们到达 main（）方法的所有途径。为体会此时发生的事情，请试试
下面这个例子：
//： NeverCaught。java
// Ignoring RuntimeExceptions
public class NeverCaught ｛
static void f（） ｛
throw new RuntimeException（〃From f（）〃）；
｝
static void g（） ｛
f（）；
｝
public static void main（String＇＇ args） ｛
g（）；
｝
270
…………………………………………………………Page 272……………………………………………………………
｝ ///：~
大家已经看到，一个RuntimeException （或者从它继承的任何东西）属于一种特殊情况，因为编译器不要求
为这些类型指定违例规范。
输出如下：
java。lang。RuntimeException： From f（）
at NeverCaught。f（NeverCaught。java：9）
at NeverCaught。g（NeverCaught。java：12）
at NeverCaught。main（NeverCaught。java：15）
所以答案就是：假若一个RuntimeException 获得到达main（）的所有途径，同时不被捕获，那么当程序退出
时，会为那个违例调用 printStackTrace（）。
注意也许能在自己的代码中仅忽略 RuntimeException，因为编译器已正确实行了其他所有控制。因为
RuntimeException 在此时代表一个编程错误：
（1） 一个我们不能捕获的错误（例如，由客户程序员接收传递给自己方法的一个空句柄）。
（2） 作为一名程序员，一个应在自己的代码中检查的错误（如 ArrayIndexOutOfBoundException，此时应注
意数组的大小）。
可以看出，最好的做法是在这种情况下违例，因为它们有助于程序的调试。
另外一个有趣的地方是，我们不可将Java 违例划分为单一用途的工具。的确，它们设计用于控制那些讨厌的
运行期错误——由代码控制范围之外的其他力量产生。但是，它也特别有助于调试某些特殊类型的编程错
误，那些是编译器侦测不到的。
9。4 创建自己的违例
并不一定非要使用Java 违例。这一点必须掌握，因为经常都需要创建自己的违例，以便指出自己的库可能生
成的一个特殊错误——但创建 Java 分级结构的时候，这个错误是无法预知的。
为创建自己的违例类，必须从一个现有的违例类型继承——最好在含义上与新违例近似。继承一个违例相当
简单：
//： Inheriting。java
// Inheriting your own exceptions
class MyException extends Exception ｛
public MyException（） ｛｝
public MyException（String msg） ｛
super（msg）；
｝
｝
public class Inheriting ｛
public static vo id f（） throws MyException ｛
System。out。println（
〃Throwing MyException from f（）〃）；
throw new MyException（）；
｝
public static void g（） throws MyException ｛
System。out。println（
〃Throwing MyException from g（）〃）；
throw new MyException（〃Originated in g（）〃）；
｝
public static void main（String＇＇ args） ｛
try ｛
271
…………………………………………………………Page 273……………………………………………………………
f（）；
｝ catch（MyException e） ｛
e。printStackTrace（）；
｝
try ｛
g（）；
｝ catch（MyException e） ｛
e。printStackTrace（）；
｝
｝
｝ ///：~
继承在创建新类时发生：
class MyException extends Exception ｛
public MyException（） ｛｝
public MyException（String msg） ｛
super（msg）；
｝
｝
这里的关键是“extends Exception”，它的意思是：除包括一个Exception 的全部含义以外，还有更多的含
义。增加的代码数量非常少——实际只添加了两个构建器，对 MyException 的创建方式进行了定义。请记
住，假如我们不明确调用一个基础类构建器，编译器会自动调用基础类默认构建器。在第二个构建器中，通
过使用 super 关键字，明确调用了带有一个 String 参数的基础类构建器。
该程序输出结果如下：
Throwing MyException from f（）
MyException
at Inheriting。f（Inheriting。java：16）
at Inheriting。main（Inheriting。java：24）
Throwing MyException from g（）
MyException： Originated in g（）
at Inheriting。g（Inheriting。java：20）
at Inheriting。main（Inheriting。java：29）
可以看到，在从f（） “掷”出的MyException 违例中，缺乏详细的消息。
创建自己的违例时，还可以采取更多的操作。我们可添加额外的构建器及成员：
//： Inheriting2。java
// Inheriting your own exceptions
class MyException2 extends Exception ｛
public MyException2（） ｛｝
public MyException2（String msg） ｛
super（msg）；
｝
public MyException2（String msg； int x） ｛
super（msg）；
i = x；
｝
public int val（） ｛ return i； ｝
272
…………………………………………………………Page 274……………………………………………………………
private int i；
｝
public class Inheriting2 ｛
public static void f（） throws MyException2 ｛
System。out。println（
〃Throwing MyException2 from f（）〃）；
throw new MyException2（）；
｝
public static void g（） throws MyException2 ｛
System。out。println（
〃Throwing MyException2 from g（）〃）；
throw new MyException2（〃Originated in g（）〃）；
｝
public static void h（） throws MyException2 ｛
System。out。println（
〃Throwing MyException2 from h（）〃）；
throw new MyException2（
〃Originated in h（）〃； 47）；
｝
public static void main（String＇＇ args） ｛
try ｛
f（）；
｝ catch（MyException2 e） ｛
e。printStackTrace（）；
｝
try ｛
g（）；
｝ catch（MyException2 e） ｛
e。printStackTrace（）；
｝
try ｛
h（）；
｝ catch（MyException2 e） ｛
e。printStackTrace（）；
System。out。println（〃e。val（） = 〃 ＋ e。val（））；
｝
｝
｝ ///：~
此时添加了一个数据成员 i；同时添加了一个特殊的方法，用它读取那个值；也添加了一个额外的构建器，
用它设置那个值。输出结果如下：
Throwing MyException2 from f（）
MyException2
at Inheriting2。f（Inheriting2。java：22）
at Inheriting2。main（Inheriting2。java：34）
Throwing MyException2 from g（）
MyException2： Originated in g（）
at Inheriting2。g（Inheriting2。java：26）
at Inheriting2。main（Inheriting2。java：39）
Throwing MyException2 from h（）
273
…………………………………………………………Page 275……………………………………………………………
MyException2： Originated in h（）
at Inheriting2。h（Inheriting2。java：30）
at Inheriting2。main（Inheriting2。java：44）
e。val（） = 47
由于违例不过是另一种形式的对象，所以可以继续这个进程，进一步增强违例类的能力。但要注意，对使用
自己这个包的客户程�
快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部!
温馨提示： 温看小说的同时发表评论，说出自己的看法和其它小伙伴们分享也不错哦！发表书评还可以获得积分和经验奖励，认真写原创书评 被采纳为精评可以获得大量金币、积分和经验奖励哦！