java通过异常处理错误_Java学习笔记---通过异常处理错误

Java的基本理念是“结构不佳的代码不能运行”。

发现错误的理想时机是在编译阶段，也就是在你试图运行程序之前。然而，编译期间并不能找出所有的错误，余下的问题必须在运行期间解决。

这就需要错误源能通过某种方式，把适当的信息传递给某个接收者--该接收者将知道如何正确处理这个问题。

概念

基本异常

捕获异常

创建自定义异常

异常说明

捕获所有异常

Java标准异常

使用finally进行清理

异常的限制

构造器

异常匹配

其他可选方式

异常使用指南

总结

1.概念

c以及早期错误处理往往建立在约定俗成的基础之上，而不属于语言的一部分。通常会返回某个特殊值或者设置一个标志，并且假定接受者将对这个返回值或标志进行检查，以判定是否发生了错误。但是，随着时间的推移，高傲的程序员在使用程序的库的时候更倾向于认为：“对，错误也许会发生，但那是别人造成的，不关我的事”。所以，程序员不去检查错误就不足为奇了。

如果的确在每次调用方法的时候都彻底地进行错误检查，代码很可能会变得难以阅读。

解决的办法是，用强制规定的形式来消除错误处理过程中随心所欲的因素。这种做法由来已久，C++异常处理机制基于Ada，Java中的异常处理则建立在C++的基础之上。

问题出现了，或许不清楚该如何处理，但是绝不能置之不理；得停下来，看看是不是有别人或在别的地方，能够处理这个问题。只是在当前的环境中还没有足够的信息来解决这个问题，所以就把这个问题提交到更高级别的环境中，在这里将做出正确的决定。

使用异常所带来的另一个好处就是，往往能够降低错误处理代码的复杂度。如果不使用异常，那么就必须检查特定的错误，并在程序中的许多地方去处理它。而如果使用异常，就不必在方法调用处进行检查，因为异常机制将保证能够捕获这个错误。并且只需在一个地方处理错误，即所谓的异常处理程序中。这种方式不仅节省代码，而且把“描述在正常执行过程中做什么事”的代码和“出了问题怎么办”的代码相分离。

总之，与以前的错误处理方法相比，异常机制使得代码的阅读、编写和调试工作更加井井有条。

2.基本异常

异常情形是指阻止当前方法或作用域继续执行的问题。把异常情形与普通问题相区分很重要，所谓的普通问题是指，在当前环境下能得到足够的信息，总能处理这个错误。而对于异常情形，就不能继续下去了，因为在当前环境下无法获得必要的信息来解决问题。你所能做的就是从当前环境跳出，并且把问题提交给上一级环境。这就是抛出异常时所发生的事情。

有个简单的例子：除法。除数有可能为0，所以先进行检查很有必要。但除数为0代表的究竟是什么意思，通过当前正在解决的问题环境，或许能知道该如何处理除数为0的情况。但如果这是一个意料之外的值，你也不清楚该如何处理，那就要抛出异常，而不是顺着原来的路径继续执行下去。

抛出异常后，会有几件事随之发生:首先，同Java中其他对象的创建一样，将使用new在堆上创建异常对象。然后，当前执行路径被终止。并且从当前环境中弹出对异常对象的引用。此时，异常处理机制接管程序，并开始寻找一个恰当的地方来继续执行程序。这个恰当的地方就是异常处理程序，它的任务是将程序从错误状态中恢复，以使程序能要么换一种方式运行，要么继续运行下去。

举一个抛出异常的例子：

对于对象引用t，传给你的时候可尚未被初始化，所以在使用这个对象引用调用其方法之前，会先对引用进行检查。可以创建一个代表错误信息的对象，并且将它从当前环境中“抛出”，这样就把错误信息传播到了“更大”的环境中。这被称为抛出一个异常，看起来就像：

这就抛出了异常，于是在当前环境下就不必再为这个问题操心了，它将在别的地方得到处理。

异常使得我们可以将每件事都当作一个事务来考虑，而异常可以看护着这些事务的底线。“...事务的基本保障是我们所需的在分布式计算中的异常处理。事务是计算机中的合同法，如果出了什么问题，我们只需要放弃整个计算。”还可以将异常看作是一种内建的恢复系统，因为我们在程序中可以拥有各种不同的恢复点。如果程序的某部分失败了，异常将“恢复”到程序中某个已知的稳定点上。

异常最重要的方面之一就是如果发生问题，它将不允许程序沿着其正常的路径继续走下去。异常允许我们强制程序停止运行，并告诉我们出现了什么问题，或者强制程序处理问题，并返回到稳定状态。

异常参数：

与使用Java中的其他对象一样，总是用new在堆上创建异常对象，这也伴随着存储空间的分配和构造器的调用。所有标准异常类都有两个构造器：一个是默认构造器；另一个是接受字符串作为参数，以便能把相关信息放入异常对象的构造器：

要把这个字符串的内容提取出来可以有多种不同的方法：

在使用new创建了异常对象之后，此对象的引用将传给throw。

虽然，返回的异常对象其类型通常与方法设计的返回类型不同，但从效果上看，就像是从方法“返回”的。

1).可以简单地把异常处理看成一种不同的返回机制，当然若过分强调这种类比的话，就会产生麻烦；

2).另外还能用抛出异常的方式从当前的作用域退出。

在这两种情况下，将会返回一个异常对象，然后退出方法或作用域。

抛出异常与方法正常返回值的相似之处到此为止。因为异常返回的“地点”与普通方法调用返回的“地点”不同(异常将在一个恰当的异常处理程序中得到解决，它的位置可能离异常被抛出的地方很远，也可能会跨越方法调用栈的许多层次。)

此外，能够抛出任意类型的Throwable对象，它是异常类型的根类。通常，对于不同类型的错误，要抛出相应的异常。错误信息可以保存在异常对象内部或者用异常类的名称来暗示。上一层环境通过这些信息来决定如何处理异常。(通常，异常对象中仅有的信息就是异常类型，除此之外不包含任何有意义的内容)

3.捕获异常

要理解异常是如何被捕获的，必须首先理解监控区域的概念。它是一段可能产生异常的代码，并且后面跟着处理这些异常的代码。

try块：

如果在方法内部抛出了异常(或者在方法内部调用的其他方法抛出了异常)，这个方法将在抛出异常的过程中结束。要是不希望方法就此结束，可以在方法内设置一个特殊的块来捕获异常。因为在这个块里尝试各种(可能产生异常的)方法调用，所以称为try块。它是跟在try关键字之后的普通程序块：

try块里是可能产生异常的代码

对于不支持异常处理的程序语言，要想进行仔细的检查错误，就得在每个方法调用的前后加上设置和错误检查的代码，甚至在每一次调用同一方法时也得这么做。

有了异常处理机制，可以把所有动作都放在try块里，然后只需在一个地方就可以捕获所有异常。

异常处理程序：

抛出的异常必须在某处得到处理。这个“地点”就是异常处理程序，而且针对每个要捕获的异常，得准备相应的处理程序。异常处理程序紧跟在try块之后，以关键字catch表示：

每个catch子句(异常处理程序)看起来就像是接收一个且仅接收一个特殊类型的参数的方法。

可以在处理程序的内部使用标识符(id1,id2)，这与方法参数的使用很相似。

有时可能用不到标识符，因为异常的类型已经给了足够的信息来对异常进行处理，但标识符并不可以省略。

异常处理程序必须紧跟在try块之后，当异常被抛出时，异常处理机制将负责搜寻参数与异常类型相匹配的第一个处理程序。然后进入catch子句执行，此时认为异常得到了处理。一旦catch子句结束，则处理程序的查找过程结束。

只有匹配的catch子句才能得到执行；

在try块内部，不同的方法调用可能会产生类型相同的异常，而你只需提供一个针对此类型的异常处理程序。

终止恢复：

异常处理理论上有两种基本模型。Java支持终止模型。

在这种模式中，将假设错误非常关键，以至于程序无法返回到异常发生的地方继续执行。一旦异常被抛出，就表明错误无法挽回，也不能回来继续执行。

另一种称为恢复模型。意思是异常处理程序的工作是修正错误，然后重新尝试调用出问题的方法，并认为第二次能成功。

对于恢复模型，通常希望异常被处理之后能继续执行程序。

如果想要用Java实现类似恢复的行为，那么预见错误时就不能抛出异常，而是调用方法来修正该错误。或者，把try块放在while循环里面，这样就不断地进入try块，直到得到满意的结果。

虽然系统支持恢复模型，但长久以来，程序员最终还是转向使用“终止模型”，并且忽略恢复行为。

恢复模型刚开始出来的时候确实很吸引人，但不是很实用，原因就是：恢复行为导致的耦合：恢复性的处理程序需要了解异常抛出的地点，这势必要包含依赖于抛出位置的非通用性代码。这增加了代码编写和维护的困难，对于异常可能会从许多地方抛出的大型程序来说，更是如此。

4.创建自定义异常

不必拘泥于Java已有的异常类型。Java提供的异常体系不可能预见所有的希望加以报告的错误，所以可以自己定义异常类来表示程序中可能会遇到的特定问题。

要自己定义异常类，必须从已有的异常类继承，最好是选择意思相近的异常类继承。建立新的异常类最简单的方法就是让编译器为你产生默认构造器，所以这几乎不用写多少代码：

编译器创建了默认构造器，它将自动调用基类的默认构造器。

本例中不会得到像SimpleException(String)这样的构造器，这种构造器也不实用。

对异常来说，最重要的部分就是类名，所以本例中建立的异常类在大多数情况下已经够用了。

结果可以看到，输出显示系统正是在控制台上自动地捕获和测试这些结果。但是，你也许想通过写入System.err而将错误发送给标准错误流。通常这比把错误信息输出到System.out要好，因为System.out也许会被重定向。如果把结果送到System.err，它就不会随System.out一起被重定向，这样更容易被用户注意。

也可以为异常类定义一个接受字符串参数的构造器：

 新增的代码：两个构造器定义了MyException类型对象的创建方式。对于第二个构造器，使用super关键字明确调用了其基类构造器，它接受一个字符串作为参数。

在异常处理程序中，调用了在Throwable类声明(Exception即从此类继承)的printStackTrace()方法。它将打印“从方法调用处直到异常抛出处”的方法调用序列。这里，信息被发送到了System.out，并自动地被捕获和显示在输出中。

如果调用默认版本：

则信息将被输出到标准错误流(非System.out)；

异常与记录日志：

对于程序员，可能还想使用java.util.logging工具将输出记录到日志中。

结果：

静态的Logger.getLogger()方法创建了一个String参数相关联的Logger对象；这个Logger对象会将其输出发送到System.err。

向Logger写入的最简单方式就是直接调用与日志记录消息的级别相关联的方法，这里使用的是severe()。为了产生日志记录消息，我们欲获取异常抛出处的栈轨迹，但是printStackTrace()方法，它接受一个java.io.PrintWriter对象作为参数。

如果我们将一个java.io.StringWriter对象传递给这个PrintWriter的构造器，那么通过调用toString()方法，就可以将输出抽取为一个String。

尽管由于LoggingException将所有记录日志的基础设施都构建在异常自身中，使得它所使用的方式非常方便，并因此不需要客户端程序员的干预就可以自动运行，但是更常见的情形是我们需要捕获和记录其他人编写的异常，因此我们必须在异常处理程序中生成日志消息。

还可以进一步自定义异常，比如加入额外的构造器和成员：

新的异常添加了字段x以及设定x值的构造器和读取数据的方法。此外，还覆盖了Throwable.getMessage()方法,以产生更详细的信息。对于异常类来说，getMessage()方法有点类似于toString()方法。

既然异常也是对象的一种，所以可以继续修改这个异常类，以得到更强的功能，但是对异常所添加的其他功能也许根本就用不上。

5.异常说明

Java鼓励人们把方法可能会抛出的异常告知使用此方法的客户端程序员。这是种优雅的做法，它使得调用者能确切知道写什么样的代码可以捕获所有潜在的异常。当然，如果提供了源代码，客户端程序员可以在源代码中查找throw语句来获知相关信息，然而程序库通常并不与源代码一起发布。

为了解决上面的问题，Java提供了相应的语法，使得你能以礼貌的方式告知客户端程序员某个方法可能会抛出的异常类型，然后客户端程序员就可以进行相应的处理。这就是异常说明，它属于方法声明的一部分，紧跟在形式参数列表之后。

异常说明使用了附加的关键字throws，后面接一个所有潜在异常类型的列表，所以方法定义可能看起来像这样：

但是，要是写成这样：

就表示此方法不会抛出任何异常(除了从RuntimeException继承的异常，它们就可以在没有异常说明的情况下被抛出，这些将在后面进行讨论)

代码必须与异常说明保持一致。如果方法里的代码产生了异常却没有进行处理，编译器会发现这个问题并提醒你：要么处理这个异常，要么就在异常说明中表明此方法将产生异常。通过这种自顶向下强制执行的异常说明机制，Java在编译时就可以保证一定水平的异常正确性。

不过还是有个能作弊的地方：可以声明方法将抛出异常，实际上却不抛出。编译器相信了这个声明，并强制此方法的用户像真的抛出异常而不用修改已有的代码。在定义抽象基类和接口时这种能力很重要，这样派生类或接口实现就能够抛出这些预先声明的异常。

这种在编译时被强制检查的异常被称为被检查的异常。

6.捕获所有异常

可以只写一个异常处理程序来捕获所有类型的异常。通过捕获异常类型的基类Exception，就可以做到这一点(事实上，还要其他的基类，但Exception是同编程活动相关的基类)：

这将捕获所有异常。

所以最好把它放在处理程序列表的末尾，以防它抢在其他处理程序之前先把异常捕获了。

因为Exception是与编程有关的所有异常类的基类，所以它不会包含太多具体的信息，不过可以调用它从其基类Throwable继承的方法：

用来获取详细信息，或用本地语言表示的详细信息。

返回对Throwable的简单描述，要是有详细信息的haunted，也会把它包含在内。

打印Throwable和Throwable的调用栈轨迹。调用栈显示了“把你带到异常抛出地点”的方法调用序列。

第一个版本输出到标准错误，后两个版本允许选择要输出的流。

用于在Throwable对象的内部记录栈的当前状态。这在程序重新抛出错误或异常时很有用。

此外，也可以使用Throwable从其基类Object集成的方法。对于异常来说，getClass()也许是个很好用的方法，它将返回一个表示此对象类型的对象。然后可以使用getName()方法来查询这个Class对象包含信息的名称，或者使用只产生类名称的getSimpleName()方法。

下面例子演示了如何使用Exception类型的方法：

可以发现每个方法都比前一个提供了更多的信息--实际上它们每一个都是前一个的超集。

栈轨迹：

printStackTrace()方法所提供的信息可以通过getStackTrace()方法来直接访问，这个方法将返回一个由栈轨迹中的元素所构成的数组，其中每一个元素都表示栈中的一帧。元素0是栈顶元素，并且是调用序列中的最后一个方法调用(这个Throwable被创建和抛出之处)。数组中的最后一个和栈底是调用序列中的第一个方法调用。

下面是一个简单的演示示例：

这里，我们只打印了方法名，但实际上还可以打印整个StackTraceElement，它包含其他附件的信息。

重新抛出异常：

有时希望把刚捕获的异常重新抛出，尤其是在使用Exception捕获所有异常的时候。既然已经得到了对当前异常对象的引用，可以直接把它重新抛出：

重抛异常会把异常抛给上一级环境中的异常处理程序，同一个try块的后续catch子句将被忽略。此外，异常对象的所有信息都得以保持，所以高一级环境中捕获此异常的处理程序可以从这个异常对象中得到所有信息。

如果只是把当前异常对象重新抛出，那么printStackTrace()方法显示的将是原来异常抛出点的调用栈信息，而并非重新抛出点的信息。要想更新这个信息，可以调用fillInStackTrace()方法，这将返回一个Throwable对象，它是通过把当前调用栈信息填入原来那个异常对象而建立的，就像这样：

调用fillInStackTrace()的那一行就成了异常的新发生地了。

有可能在捕获异常之后抛出另一种异常。这么做的话，得到的效果类似于使用fillInStackTrace()，有关原来异常发生点的信息会丢失，剩下的是与新的抛出点有关的信息。

最后那个异常仅知道自己来自于main(),而对f()一无所知。

永远不必为清理前一个异常对象而担心，或者说为异常对象的清理而担心。它们都是用new在堆上创建的对象，所以垃圾回收期会自动把它们清理掉。

异常链：

常常会想在捕获一个异常之后抛出另一个异常，并且希望把原始异常的信息保存下来，这被称为异常链。

所有的Throwable的子类在构造器中都可以接受一个cause(因由)对象作为参数。这个cause就用来表示原始异常，这样通过把原始异常传递给新的异常，使得即使在当前位置创建并抛出了新的异常，也能通过这个异常链追踪到异常最初发生的位置。

在Throwable的子类中，只有三种基本的异常类提供了带cause参数的构造器。它们是Error(用于Java虚拟机报告系统错误)、Exception以及RuntimeException。如果要把其他类型的异常链接起来，就应该使用intiCause()方法而不是构造器。

下面例子能让你在运行时动态地向DynamicFields对象添加字段：

每个DynamicFields对象都含有一个数组，其元素是“成对的对象”。第一个对象表示字段标识符，第二个表示字段值，值的类型可以是除基本类型外的任意类型。

当创建对象的时候，要合理估计一下需要多少字段。当调用setField()方法的时候，它将试图通过标志修改已有字段值，否则就建一个新的字段，并把值放入。

如果空间不够了，将建立一个更长的数组，并把原来数组的元素复制进去。如果你试图为字段设置一个空值，将抛出一个DynamicFieldException异常，它是通过使用initCause()方法把NullPointException对象插入而建立的。

置于返回值，setField()将用getField()方法把此位置的旧值取出，这个操作可能会抛出NoSuchFieldException异常。如果客户端程序员调用了getField()方法，那么他就有责任处理这个可能抛出的NoSuchFieldException异常，但是如果异常是从setField()方法里抛出的，这种情况将被视为编程错误，所以就使用接受cause参数的构造器把NoSuchFieldException异常转换为RuntimeException异常。

7.Java标准异常

Throwable这个Java类被用来表示任何可以作为异常被抛出的类。Throwable对象可分两种类型(指从Throwable继承而得到的类型)：Error用来表示编译时和系统错误(除特殊情况外，一般不用客户程序员关心)；Exception是可以被抛出的基本类型，在Java类库、用户方法以及运行时故障中都可能抛出Exception型异常。所以Java程序员关心的基类型通常是Exception。

对异常来说，关键是理解概念及如何使用。

异常的基本的概念是用名称代表发生的问题，并且异常的名称应该可以望文生意。异常并非全是在java.lang包里定义的；有些异常是用来支持其他像util、net和io这样的程序包，这些异常可以通过它们的完整名称或者从它们的父类中看出端倪。比如，所有的输入/输出异常都是从java.io.IOException继承而来的。

特例：RuntimeException：

下面列子：

如果必须对传递给方法的每个引用都检查其是否为null，这听起来很吓人。但是，这不必你亲自来做，它属于Java的标准运行时检测的一部分。如果对null引用进行调用，Java会自动抛出NullPointerException异常，所以上述代码是多余的，尽管你也许想要执行其他的检查以确保NullPointerException不会出现。、

属于运行时异常的类型很多，它们会自动被Java虚拟机抛出，所以不必在异常说明中把它们列出来。这些异常都是从RuntimeException类继承而来，所以既体现了继承的优点，使用起来也很方便。这构成了一组具有相同特征和行为的异常类型。

并且，也不再需要在异常说明中声明方法将抛出RuntimeException类型的异常(或者任何从RuntimeException继承的异常)，它们也被称为“不受检查异常”。

这种异常属于错误，将被自动捕获；尽管通常不用捕获RuntimeException异常，但是可以在代码中抛出RuntimeException类型的异常。

如果不捕获这种类型的异常会发生什么事呢？因为编译器没有在这个问题上对异常说明进行强制检查，RuntimeException类型的异常也许会穿越所有的执行路劲直达mian()方法，而不会被捕获。

下面例子可以明白到底发生了什么？

RuntimeException(或任何从它继承的异常)是一个特例。对于这种异常类型，编译器不需要异常说明，其输出被报告给了System.err:

所以答案是：如果RuntimeException没有被捕获而直达main()，那么在程序推出前将调用异常的printStackTrace()方法。

必须要记住：只能在代码中忽略RuntimeException(及其子类)类型的异常，其他类型异常的处理都是由编译器强制实施的。究其原因，RuntimeException代表的是编程错误：

1).无法预料的错误。比如从你控制范围之外传递进来的null引用。

2).作为程序员，应该在代码中进行检查的错误。(比如对于ArrayIndexOutOfBoundsException，就得注意一下数组的大小了。)在一个地方发生的异常，常常会在另一个地方导致错误。

需要注意：不应把Java的异常处理机制当成是单一用途的工具。是的，它被设计用来处理一些烦人的运行时错误，这些错误往往是由代码控制能力之外的因素导致的；然而，他对于发现某些编译器无法检测到的编程错误，也是非常重要的。

8.使用finally进行清理

对于一些代码，可能希望无论try块中的异常是否抛出，它们都能得到执行。这通常适用于内存回收之外的情况(因为回收由垃圾回收器完成)。为了达到这个效果，可以在异常处理程序后面加上finally子句。完整的异常处理程序看起来像这样：

下面例子证明finally总是会被执行：

可以从输出中发现，无论异常是否被抛出，finally子句总能被执行。

这个程序也给了我们一些思路，当Java中的异常不允许我们回到异常抛出的地点时，那么该如何应对呢？如果把try块放在循环里，就建立了一个“程序继续执行之前必须要达到”的条件。还可以加入一个static类型的计数器或者别的装置，使循环在放弃以前能尝试一定的次数。这将使得程序的健壮性更上一个台阶。

finally用来做什么：

对于没有垃圾回收和析构函数自动调用机制的语言来说，finally非常重要。它使得程序员保证：无论try块里发生了什么，内存总能得到释放。但Java有垃圾回收机制，所以内存释放不再是问题。而且，Java也没有析构函数可供调用。那么Java在什么情况下才能用到finally呢？

当要把除内存之外的资源恢复到它们的初始化状态时，就要用到finally子句。这种需要清理的资源包括：已经打开的文件或网络连接，在屏幕上画的图形，甚至可以是外部世界的某个开关，如下面的例子所示：

程序的目的是要确保main()结束的时候开关必须是关闭的，所以每个try块和异常处理程序的末尾都加入了对sw.off()方法的调用。

但也可能有这种情况：异常被抛出，但没被处理程序捕获，这时sw.off()就得不到调用。但是有了finally，只要把try块中的清理代码移放在一处即可：

这里sw.off()被移到一处，并且保证在任何情况下都能得到执行。

甚至在异常没有被当前的异常处理程序捕获的情况下，异常处理机制也会在跳到更高一层的异常处理程序之前，执行finally子句：

在return中使用finally：

因为finally子句总是会执行的，所以在一个方法中，可以从多个点返回，并且可以保证重要的清理工作仍旧会执行：

在finally前有return；

从输出中可以看出，在finally类内部，从何处返回无关紧要。

缺憾：异常丢失：

遗憾的是，Java的异常实现也有瑕疵。异常作为程序出错的标志，绝不应该被忽略，但它还是有可能别轻易地忽略。用某些特殊的方式使用finally子句，就会发生这种情况：

这里为什么丢失了VeryImportException异常？

从输出中可以看到，VeryImportException不见了，它被finally子句的HoHumException所取代。

这是相当严重的缺陷，因为异常可能会以一种比前面例子所示更微妙和难以察觉的方式完全丢失。相比之下，C++把“前一个异常还没解决就抛出下一个异常”的情形看成是糟糕的编程错误。

一种更简单的丢失异常的方式是从finally子句中返回：

如果运行这个程序，就会看到即使抛出了异常，它也不会产生任何输出。因为在finally有一个return，将结果返回了？

9.异常的限制

当覆盖方法的时候，只能抛出在基类方法的异常说明里列出的那些异常。这个限制很有用，因为这意味着，当基类使用的代码应用到其派生类对象的时候，一样能够工作(面向对象的基本概念)，异常也不例外。

下面例子演示了这种施加在异常上面的限制：

在Inning类中，可以看到构造器和event()方法都声明将抛出异常，但实际上没有抛出，这种方式使你能强制用户去捕获可能在覆盖后的event()版本中增加的异常，所以它很合理。这对于抽象方法同样成立，比如atBat()。

接口Storm值得注意，因为它包含了一个在Inning中定义的方法event()和一个不在Inning中定义的方法rainHard()。这两个方法都抛出新的异常RainedOut。如果StormyInning类在扩展Inning类的同时又出现了Storm接口，那么Storm里的event()方法就不能改变在Inning中的event()方法的异常接口。否则的话，在使用基类的时候就不能判断是否捕获了正确的异常，所以这也很合理。当然，如果接口里定义的方法不是来自于基类，比如rainHard()，那么此方法抛出什么样的异常都没有问题。

异常限制对构造器不起作用。你会发现StormInning的构造器可以抛出任何异常，而不必理会基类构造器所抛出的异常。然而，因为基类构造器必须以这样或那样的方式被调用，派生类构造器的异常说明必须包含基类构造器的异常说明。

派生类构造器不能捕获基类构造器抛出的异常。

StormyInning.walk()不能通过变异的原因是因为：它抛出了异常，而Inning.walk()并没有声明此异常。如果编译器允许这么做的话，就可以在调用Inning.walk()的时候不用做异常处理了，而且当把它替换成Inning的派生类的对象时，这个方法就有可能会抛出异常，于是程序就失灵了。通过强制派生类遵守基类方法的异常说明，对象的可替换性得到了保证。

覆盖后的event()方法声明，派生类方法可以不抛出任何异常，即使它是基类所定义的异常。同样这是因为，假使基类的方法会抛出异常，这样做也不会破坏已有的程序，所以也没有问题。类似的情况出现在atBat()身上，它抛出的是PopFoul，这个异常是继承自“会被基类的atBat()抛出”的Foul。这样，如果你写的代码是同Inning打交道，并且调用了它的atBat()的话，那么肯定能捕获Foul。而PopFoul是由Foul派生出来的，因此异常处理程序也能捕获PopFoul。

最后一个值得注意的是mian(),这里可以看到，如果处理的刚好是StormyInning对象的话，编译器只会强制要求你捕获这个类所抛出的异常。但是如果将它向上转型成基类型，那么编译器就会要求你捕获基类的异常。所有这些限制都是为了能产生更为强壮的异常处理代码。

尽管在继承过程中，编译器会对异常说明做强制要求，但异常说明本身并不属于方法类型的一部分，方法类型是由方法的名字与参数的类型组成的。因此，不能基于异常说明来重载方法。此外，一个出现在基类方法的异常说明中的异常，不一定会出现在派生类方法的异常说明里。这点同继承的过程中，某个特定方法的“异常说明的接口”不是变大了而是变小了--这恰好和类接口在继承时的情形相反。

10.构造器

构造器会把对象设置成安全的初始状态，但还会有别的动作，比如打开一个文件，这样的动作只有在对象使用完毕并且用户调用了特殊的清理方法之后才能得以清理。如果在构造器内抛出了异常，这些清理行为也许就不能正常工作了。这意味着在编写构造器时要格外小心。

可能会觉得使用finally就可以解决问题，但问题并非如此简单，因为finally会每次都执行清理代码。如果构造器在其执行过程中半途而废，也许该对象的某些部分还没有被成功创建，而这些部分在finally子句中却是要别清理的。

在下面的例子中，建立了一个InputFile类，它能打开一个文件并且每次读其中的一行。这里使用了Java标准输入/输出库中的FileReader和BufferedReader类：

InputFile的构造器接受字符串作为参数，该字符串表示所要打开的文件名。在try块中，使用此文件名建立了FileReader对象。FileReader对象本身用处并不大，但可以用它来建立BufferedReader对象。使用InputFile的好处就能把两步操作合二为一。

如果FileReader的构造器失败了，将抛出FileNoFoundException异常。对于这个异常，并不需要关闭文件，因为这个文件还没有被打开。而任何其他捕获异常的catch子句必须关闭文件，因为在它们捕获到异常之时，文件已经打开了。

close()方法也可能会抛出异常，所以尽管它已经在另一个Catch子句块里了，还是要再用一层try-catch--对Java编译器而言，这只不过是又多了一对花括号。在本地做完处理之后，异常被重新抛出，对于构造器而言这么做是很合适的，因为你总不希望取误导调用方，让他认为“这个对象已经创建完毕，可以使用了”。

在本例中，由于finally会在每次完成构造器之后都执行一遍，因此它实在不该是调用close()关闭文件的地方。我们希望文件在InputFile对象的整个生命周期内都处于打开状态。

getLine()方法会返回表示文件下一行内容的字符串。它调用了能抛出异常的readLine()，但是这个异常已经在方法内得到处理，因此getLine()不会抛出任何异常。在设计异常时，有一个问题：应该把异常全部放在这一层处理；还是先处理一部分，然后再向上层抛出相同的异常；又或者是不做任何处理直接向上层抛出。如果用法恰当的话，直接向上层抛出的确能简化编程。在这里，getLine()方法将异常转换为RuntimeException，表示一个编程错误。

用户在不再需要InputFile对象时，就必须调用dispose()方法，这将释放BufferedReader和/或FileReader对象所占用的系统资源，在使用完InputFile对象之前是不会调用它的。可能你会考虑把上述功能放到finalize()里面，但是前面说过，你不知道finalize()什么时候能被调用。

对于在构造阶段可能会抛出异常，并且要求清理的类，最安全的使用方式是使用嵌套的try子句：

仔细观察这里的逻辑：对InputFile对象的构造器在其自己的try语句块中有效，如果构造失败，将进入外部的catch子句，而dispose方法不会被调用。

但是，如果构造成功，若想确保对象能够被清理，在构造之后立即创建一个新的try语句块。执行清理的finally与内部的try语句块相关联。在这种方式中，finally子句在构造失败时是不会执行的，而在构成成功时将总是执行。

这种通用的清理惯用法在构造器不抛出任何异常时也应该运用，其基本规则是：在创建需要清理的对象之后，立即进入一个try-catch语句块：

在main()中，Section 1相当简单：遵循了在可去除对象之后紧跟try-finally的原则。如果对象构造不能失败，就不需要任何catch。在Section 2中，为了构造和清理，可以看到具有不能失败的构造器的对象可以群组在一起。

Section 3展示了如何处理那些具有可以失败的构造器，且需要清理的对象。对于每个构造器，都包含在其自己的try-finally语句块中，并且每一个对象构造都必须跟随一个try-finally语句块以确保清理。

本例中的异常处理的棘手程度，对于应该创建不能失败的构造器是一个有力的论据，尽管这么做并非总是可行。

dispose()可以抛出异常，那么你可能需要额外的try语句块。基本上，你应该仔细考虑所有的可能性，并确保正确处理每一种情况。

11.异常匹配

抛出异常的时候，异常处理系统会按照代码的书写顺序找出“最近”的处理程序。找到匹配的处理程序之后，它就认为异常将得到处理，然后就不再继续查找了。

查找的时候并不要求抛出的异常同处理程序所声明的异常完全匹配。派生类的对象也可以匹配其基类的处理程序，就像这样：

Sneeze异常会被第一个匹配的catch子句捕获，也就是程序里的第一个。然而如果将这个catch子句删掉，只留下Annoyance的catch子句，该程序仍然能运行，因为这次捕获的是Sneeze的基类。

换句话说，catch(Annoyance e)会捕获Annoyance以及所有从它派生的异常。这一点非常有用，因为如果决定在方法里加上更多派生异常的话，只要客户程序员捕获的是基类异常，那么它们的代码就无需更改。

如果把捕获基类的catch子句放在最前面，以此把派生类的异常全给“屏蔽”掉，就像这样：

这样编译器就会发现Sneeze的catch子句永远也得不到执行，因此它会向你报告错误。

12.其他可选方式

异常处理系统就像一个活门(trap door)，使你能放弃程序的正常执行序列。当“异常情形”发生的时候，正常的执行已变得不可能或者不需要了，这时就要用到这个“活门”。异常代表了当前方法不能继续执行的情形。

开发异常处理系统的原因是，如果为每个方法所有可能发生的错误都进行处理的话，任务就显得过于繁重了。结果常常是将错误忽略。开发异常处理的初衷是为了方便程序员处理错误。

异常处理的一个重要原则“只有在你知道如何处理的情况下才捕获异常”。实际上，异常处理的一个重要目标就是把错误处理的代码同错误发生的地点相分离。这样，主干代码就不会与错误处理逻辑混在一起，也更容易理解和维护。通过允许一个处理程序去处理多个出错点，异常处理还使得错误处理代码的数量趋向于减少。

“被检查的异常”使得这个问题变得有些复杂，因为它们强制你在可能还没准备好处理错误的时候被迫加上catch子句，这就导致了吞食则有害的问题：

程序员只做最简单的事情，常常是无意中“吞食”了异常；

然而，一旦这么做，虽然能通过编译，但除非你记得复查并改正代码，否则异常将会丢失。异常确实发横了，但“吞食”精辟它却完全消失了。

因为编译器强迫你立刻写代码来处理异常，所以这种看起来最简单的方法，却可能是最糟糕的做法。

历史：

观点：

把异常传递给控制台：

对于简单的程序，最简单而又不用写多少代码就能保护异常信息的方法，就是把它们从main()传递到控制台。例如，为了读取信息而打开一个文件，必须对FileInputStream进行打开和关闭操作，这就可能会产生异常。对于简单的程序，可以像下面这么做：

main()作为一个方法也可以有异常说明，这里异常的类型是Exception，它也是所有“被检查的异常”的基类。

通过把它传递到控制台，就不必在mian()里写try-catch子句了。

把“被检查的异常”转换为“不检查的异常”：

在编写自己使用的简单程序时，从mian()中抛出的异常是很方便的，但这不是通用的方法。问题的实质是，当在一个普通方法里调用的方法时，要考虑“我不知道该这样处理这个异常，但是也不想把它“吞了”，或者打印一些无用的消息。JDK1.4的异常链提供了一种新的思路来解决这个问题。可以直接把“被检查的异常”包装进RuntimeException里面，就像这样：

如果想把“被检查的异常”这种功能“屏蔽”掉的话，这看上去像是一个好方法。不用“吞下”异常，也不必把它放到方法的异常说明里面，而异常链还能保证你不会丢失任何原始异常的信息。

这种技巧给了你一种选择，你可以不写try-catch子句或异常说明，直接忽略异常，让它沿着调用栈往上“冒泡”。同时，还可以用getCause()捕获并处理特定的异常，就像下面：

WrapCheckedException.throwRuntimeException()的代码可以生成不同类型的异常。这些异常被捕获并包装进了RuntimeException对象，所以它们成了这些运行时异常的“cause”了。

在TurnOffChecking里，可以不用try块就调用throwRuntimeException()，因为它没有抛出“被检查的异常”。但是，当你准备好去捕获异常的时候，还是可以用try块来捕获任何你想捕获的异常的。应该捕获try块肯定会抛出的异常，这里就是SomeOtherException。RuntimeException要放到最后去捕获。然后把getCause()的结果抛出来，这样就把原先的那个异常给提取出来了，然后就可以用它们自己的catch子句进行处理。

本书余下部分将会在合适的时候使用这种“用RuntimeException来包装‘被检查的异常’”的技术，另一种解决方案是创建自己的RuntimeException的子类。在这种方式中，不必捕获它，但是希望得到它的其他代码都可以捕获它。

13.异常使用指南

应该在下列情况下使用异常：

1).在恰当的级别处理问题。

2).解决问题并且重新调用产生异常的方法。

3).进行少许修补，然后异常发生的地方继续执行。

4).用别的数据进行计算，以代替方法预计会返回的值。

5).把当前运行环境下能做的事情尽量做完，然后把相同的异常重抛到更高层。

6).把当前运行环境下能做的事情尽量做完，然后把不同的异常抛到更高层。

7).终止程序。

8).进行简化。(如果你的异常模式使问题变得太复杂，那用起来会非常痛苦也很烦人)

9).让类库和程序更安全。(这既是在为调试做短期投资，也是在为程序的健壮性做长期投资。)

14.总结