update

Author: waylau

README.md

@@ -7,7 +7,7 @@ Essential Java, is a book about the Essentials of Java Programming.
 There is also a GitBook version of this book: <http://waylau.gitbooks.io/essential-java>.
 
 
-《Java 编程要点》是一本 Java 的开源学习教程，主要介绍 Java 中应用广泛的部分（言外之意，本书不涉 Applet 以及 GUI 框架）。本书也会包括最新版本 Java 8 中的新特性，图文并茂，并通过大量实例让你走近 Java 的世界！
+《Java 编程要点》是一本 Java 的开源学习教程，主要介绍 Java 中应用广泛的部分（言外之意，本书不涉 Applet 以及 GUI 框架）。本书包括最新版本 Java 8 中的新特性，以及部分 JDK 9里面的内容，图文并茂，并通过大量实例带你走近 Java 的世界！
 
 本书业余时间所著，水平有限、时间紧张，难免疏漏，欢迎指正，
 

SUMMARY.md

@@ -30,7 +30,8 @@
     * [I/O 模型的演进](docs/io-model.md)
 * [JDBC](docs/jdbc.md)
 * [异常](docs/exceptions.md)
-    * [捕获、处理异常](docs/exceptions-catch-and-handle.md)
+    * [异常捕获与处理](docs/exceptions-catch-and-handle.md)
+    * [通过方法声明异常抛出](docs/exceptions-specify-exceptions-thrown.md)
     * [如何抛出异常](docs/exceptions-throw.md)
     * [使用 try-with-resources 声明](docs/exceptions-try-with-resources.md)
     * [未检查异常](docs/exceptions-unchecked-exception.md)

docs/exceptions-catch-and-handle.md

@@ -1,2 +1,283 @@
-# 捕获、处理异常
+# 异常捕获与处理
+
+本节介绍如何使用三个异常处理程序组件（try、catch 和 finally）来编写异常处理程序。 然后，介绍了 Java SE 7中引入的 try-with-resources 语句。 try-with-resources 语句特别适合于使用`Closeable`的资源（例如流）的情况。
+
+本节的最后一部分将通过一个示例来分析在各种情况下发生的情况。
+
+以下示例定义并实现了一个名为ListOfNumbers的类。 构造时，ListOfNumbers 创建一个ArrayList，其中包含10个序列值为0到9的整数元素。ListOfNumbers类还定义了一个名为writeList的方法，该方法将数列表写入一个名为`OutFile.txt`的文本文件中。 此示例使用在`java.io`中定义的输出类，这些类包含在基本I/O中。
+
+```java
+// Note: This class will not compile yet.
+import java.io.*;
+import java.util.List;
+import java.util.ArrayList;
+
+public class ListOfNumbers {
+
+    private List<Integer> list;
+    private static final int SIZE = 10;
+
+    public ListOfNumbers () {
+        list = new ArrayList<Integer>(SIZE);
+        for (int i = 0; i < SIZE; i++) {
+            list.add(new Integer(i));
+        }
+    }
+
+    public void writeList() {
+	// The FileWriter constructor throws IOException, which must be caught.
+        PrintWriter out = new PrintWriter(new FileWriter("OutFile.txt"));
+
+        for (int i = 0; i < SIZE; i++) {
+            // The get(int) method throws IndexOutOfBoundsException, which must be caught.
+            out.println("Value at: " + i + " = " + list.get(i));
+        }
+        out.close();
+    }
+}
+```
+
+
+构造函数 FileWriter 初始化文件上的输出流。如果文件无法打开，构造函数会抛出一个IOException异常。第二个对ArrayList类的get方法的调用，如果其参数的值太小（小于0）或太大（超过ArrayList当前包含的元素数量），它将抛出 IndexOutOfBoundsException。
+
+如果尝试编译ListOfNumbers类，则编译器将打印有关FileWriter构造函数抛出的异常的错误消息。但是，它不显示有关get抛出的异常的错误消息。原因是构造函数IOException抛出的异常是一个检查异常，而get方法IndexOutOfBoundsException抛出的异常是未检查的异常。
+
+现在，我们已经熟悉ListOfNumbers类，并且知道了其中那些地方可能抛出异常。下一步我们就可以编写异常处理程序来捕获和处理这些异常。
+
+
+## try块 
+
+
+构造异常处理程序的第一步是封装可能在try块中抛出异常的代码。 一般来说，try块看起来像下面这样：
+
+```java
+try {
+    code
+}
+catch and finally blocks . . .
+```
+
+示例标记 `code` 中的段可以包含一个或多个可能抛出的异常。
+
+每行可能抛出异常的代码都可以用单独的一个 try 块，或者多个异常放置在一个 try 块中。 以下示例由于非常简短，所有使用一个try块。
+
+```java
+private List<Integer> list;
+private static final int SIZE = 10;
+
+public void writeList() {
+    PrintWriter out = null;
+    try {
+        System.out.println("Entered try statement");
+        out = new PrintWriter(new FileWriter("OutFile.txt"));
+        for (int i = 0; i < SIZE; i++) {
+            out.println("Value at: " + i + " = " + list.get(i));
+        }
+    }
+    catch and finally blocks  . . .
+}
+```
+
+
+如果在try块中发生异常，那么该异常由与其相关联的异常处理程序将会进行处理。 要将异常处理程序与try块关联，必须在其后面放置一个catch块。
+
+## catch块
+
+通过在try块之后直接提供一个或多个catch块，可以将异常处理程序与try块关联。 在try块的结尾和第一个catch块的开始之间没有代码。
+
+```java
+try {
+
+} catch (ExceptionType name) {
+
+} catch (ExceptionType name) {
+
+}
+```
+
+
+每个catch块是一个异常处理程序，处理由其参数指示的异常类型。 参数类型ExceptionType声明了处理程序可以处理的异常类型，并且必须是从Throwable类继承的类的名称。 处理程序可以使用名称引用异常。
+
+catch块包含了在调用异常处理程序时执行的代码。 当处理程序是调用堆栈中第一个与ExceptionType匹配的异常抛出的类型时，运行时系统将调用异常处理程序。 如果抛出的对象可以合法地分配给异常处理程序的参数，则系统认为它是匹配。
+
+以下是writeList方法的两个异常处理程序：
+
+```java
+try {
+
+} catch (IndexOutOfBoundsException e) {
+    System.err.println("IndexOutOfBoundsException: " + e.getMessage());
+} catch (IOException e) {
+    System.err.println("Caught IOException: " + e.getMessage());
+}
+```
+
+异常处理程序可以做的不仅仅是打印错误消息或停止程序。 它们可以执行错误恢复，提示用户做出决定，或者使用异常链将错误传播到更高级别的处理程序，如“异常链”部分所述。
+
+### 在一个异常处理程序中处理多个类型的异常
+
+
+在Java SE 7和更高版本中，单个catch块可以处理多种类型的异常。 此功能可以减少代码重复，并减少定义过于宽泛的异常。
+
+在catch子句中，多个类型的异常使用竖线（|）分隔每个异常类型：
+
+
+```java
+catch (IOException|SQLException ex) {
+    logger.log(ex);
+    throw ex;
+}
+```
+
+注意：如果catch块处理多个异常类型，则catch参数将隐式为final。 在本示例中，catch参数ex是final，因此您不能在catch块中为其分配任何值。
+
+## finally 块
+
+finally块总是在try块退出时执行。这确保即使发生意外异常也会执行finally块。但 finally 的用处不仅仅是异常处理 - 它允许程序员避免清理代码意外绕过 return、continue 或 break 。将清理代码放在finally块中总是一个好的做法，即使没有预期的异常。
+
+注意：如果在执行try或catch代码时JVM退出，则finally块可能无法执行。同样，如果执行try或catch代码的线程被中断或杀死，则finally块可能不执行，即使应用程序作为一个整体继续。
+
+
+writeList方法的try块打开一个PrintWriter。程序应该在退出writeList方法之前关闭该流。这提出了一个有点复杂的问题，因为writeList的try块可以以三种方式中的一种退出。
+
+* new FileWriter语句失败并抛出IOException。
+* list.get(i)语句失败，并抛出IndexOutOfBoundsException。
+* 一切成功，try块正常退出。
+
+运行时系统总是执行finally块内的语句，而不管try块内发生了什么。所以它是执行清理的完美场所。
+
+下面的finally块为writeList方法清理，然后关闭PrintWriter。
+
+```java
+finally {
+    if (out != null) { 
+        System.out.println("Closing PrintWriter");
+        out.close(); 
+    } else { 
+        System.out.println("PrintWriter not open");
+    } 
+} 
+```
+
+重要：finally块是防止资源泄漏的关键工具。 当关闭文件或恢复资源时，将代码放在finally块中，以确保资源始终恢复。
+
+考虑在这些情况下使用try-with-resources语句，当不再需要时自动释放系统资源。 
+
+
+## try-with-resources 语句
+
+try-with-resources 是 JDK 7 中一个新的异常处理机制，它能够很容易地关闭在 try-catch 语句块中使用的资源。所谓的资源（resource）是指在程序完成后，必须关闭的对象。try-with-resources 语句确保了每个资源在语句结束时关闭。所有实现了 [java.lang.AutoCloseable](http://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html) 接口（其中，它包括实现了 [java.io.Closeable](http://docs.oracle.com/javase/8/docs/api/java/io/Closeable.html) 的所有对象），可以使用作为资源。
+
+例如，我们自定义一个资源类
+
+```java
+public class Demo {    
+    public static void main(String[] args) {
+        try(Resource res = new Resource()) {
+            res.doSome();
+        } catch(Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+}
+
+class Resource implements AutoCloseable {
+    void doSome() {
+        System.out.println("do something");
+    }
+    @Override
+    public void close() throws Exception {
+        System.out.println("resource is closed");
+    }
+}
+```
+
+执行输出如下：
+
+    do something
+    resource is closed
+    
+可以看到，资源终止被自动关闭了。
+
+再来看一个例子，是同时关闭多个资源的情况：
+
+```java
+public class Main2 {    
+    public static void main(String[] args) {
+        try(ResourceSome some = new ResourceSome();
+             ResourceOther other = new ResourceOther()) {
+            some.doSome();
+            other.doOther();
+        } catch(Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+}
+
+class ResourceSome implements AutoCloseable {
+    void doSome() {
+        System.out.println("do something");
+    }
+    @Override
+    public void close() throws Exception {
+        System.out.println("some resource is closed");
+    }
+}
+
+class ResourceOther implements AutoCloseable {
+    void doOther() {
+        System.out.println("do other things");
+    }
+    @Override
+    public void close() throws Exception {
+        System.out.println("other resource is closed");
+    }
+}
+```
+
+最终输出为：
+
+    do something
+    do other things
+    other resource is closed
+    some resource is closed
+
+在 try 语句中越是最后使用的资源，越是最早被关闭。
+
+### try-with-resources 在 JDK 9 中的改进
+
+作为 [Milling Project Coin](http://openjdk.java.net/jeps/213) 的一部分, try-with-resources 声明在 JDK 9  已得到改进。如果你已经有一个资源是 final 或等效于 final 变量,您可以在 try-with-resources 语句中使用该变量，而无需在 try-with-resources 语句中声明一个新变量。
+
+例如,给定资源的声明
+
+    // A final resource
+    final Resource resource1 = new Resource("resource1");
+    // An effectively final resource
+    Resource resource2 = new Resource("resource2");
+        
+老方法编写代码来管理这些资源是类似的:
+
+    // Original try-with-resources statement from JDK 7 or 8
+    try (Resource r1 = resource1;
+         Resource r2 = resource2) {
+        // Use of resource1 and resource 2 through r1 and r2.
+    }
+    
+而新方法可以是
+
+    // New and improved try-with-resources statement in JDK 9
+    try (resource1;
+         resource2) {
+        // Use of resource1 and resource 2.
+    }
+    
+看上去简洁很多吧。对 Java 未来的发展信心满满。
+
+愿意尝试 JDK 9 这种新语言特性的可以下载使用 [JDK 9 快照](https://jdk9.java.net/download/)。Enjoy!
+
+### 源码
+
+本章例子的源码，可以在 <https://github.com/waylau/essential-java> 中 `com.waylau.essentialjava.exception.trywithresources` 包下找到。
+
+
 

docs/exceptions-catch-or-specify.md

@@ -0,0 +1,38 @@
+# 捕获或者声明（Catch or Specify Requirement） 
+
+有效的Java编程语言代码必须满足异常的捕获或者声明（Catch or Specify Requirement） 。 可能抛出异常的代码必须是下列两种处理方式之一:
+
+* 使用 try 捕获异常。try 必须提供处理器来处理异常，详见“[异常捕获和处理](exceptions-catch-and-handle.md)”；
+* 通过在方法签名中利用 throws 关键字，声明异常可以将异常抛出，将异常传递给调用者，自己可以不用处理。详见“[通过方法声明异常抛出](exceptions-specify-exceptions-thrown.md)”。
+
+所编写的代码如果不满足捕获或者声明异常将不会编译成功。
+
+并非所有的异常都满足捕获或者声明异常 的约束。 为了理解为什么，我们需要看看三个基本类别的例外，其中只有一个符合要求。
+
+## 三个不同的异常
+
+### 1. 已检查异常（checked exception）
+
+已检查异常是一个良好的应用程序应该预期和恢复的特殊条件。例如，假设应用程序提示用户输入文件名，然后通过将名称传递给`java.io.FileReader`的构造函数来打开该文件。通常，用户提供现有可读文件的名称，这样`FileReader`对象才能构造成功，应用程序才能执行正常进行。但有时用户提供不存在的文件的名称，并且构造函数抛出`java.io.FileNotFoundException`。一个编写良好的程序将捕获此异常并通知用户该错误，并可能地提示用户需要修正文件名。
+
+已检查异常受限于捕获或者声明异常。除了 Error、RuntimeException 和它们的子类以外，所有异常都是已检查异常。
+
+### 2. 错误（error）
+
+错误是应用程序外部的特殊条件，是应用程序通常无法预期或恢复的。例如，假设应用程序成功打开文件以进行输入，但由于硬件或系统故障而无法读取该文件。未成功读取将抛出`java.io.IOError`。应用程序可能选择捕获此异常，以便将该问题通知给用户 ，当然程序也可以选择打印堆栈跟踪并退出。
+
+错误不受捕获或者声明异常的限制。错误是由 Error 及其子类指示的异常。
+
+### 3. 运行时异常（runtime exception）
+
+运行时异常是应用程序内部的特殊情况，应用程序通常无法预期或恢复。这些通常表示编程错误，例如逻辑错误或API的不当使用。例如，考虑前面描述的将文件名传递给`FileReader`的构造函数的应用程序。如果一个逻辑错误导致一个null传递给构造函数，构造函数将抛出`NullPointerException`。应用程序可以捕获此异常，但也可能更有意义，以消除导致异常发生的错误。
+
+
+运行时异常不受捕获或者声明异常的限制。运行时异常是由 RuntimeException 及其子类指示的异常。
+
+
+错误和运行时异常统称为未检查异常（unchecked exceptions）。
+
+## 绕过捕获或者声明异常
+
+一些程序员认为不受捕获或者声明异常是异常机制的严重缺陷，并试图通过使用未检查的异常代替已检查异常来绕过它。 一般来说，这是不推荐。 “[未检查的异常](exceptions-unchecked-exception.md)”部分讨论何时使用未检查异常是恰当的。

docs/exceptions-specify-exceptions-thrown.md

@@ -0,0 +1,29 @@
+# 通过方法声明异常抛出
+
+上一节展示了如何为ListOfNumbers类中的writeList方法编写异常处理程序。 有时，它适合代码捕获可能发生在其中的异常。 但在其他情况下，最好让一个方法进一步推给上层来调用堆栈处理异常。 例如，如果您将ListOfNumbers类提供为类包的一部分，则可能无法预期包的所有用户的需求。 在这种情况下，最好不要捕获异常，并允许一个方法进一步推给上层来调用堆栈来处理它。
+
+如果writeList方法没有捕获其中可能发生的已检查异常，则writeList方法必须指定它可以抛出这些异常。 让我们修改原始的writeList方法来指定它可以抛出的异常，而不是捕捉它们。 请注意，下面是不能编译的writeList方法的原始版本。
+
+
+```
+public void writeList() {
+    PrintWriter out = new PrintWriter(new FileWriter("OutFile.txt"));
+    for (int i = 0; i < SIZE; i++) {
+        out.println("Value at: " + i + " = " + list.get(i));
+    }
+    out.close();
+}
+```
+
+
+要指定writeList可以抛出两个异常，请为writeList方法的方法声明添加一个throws子句。 throws子句包含throws关键字，后面是由该方法抛出的所有异常的逗号分隔列表。 该子句在方法名和参数列表之后，在定义方法范围的大括号之前。这里是一个例子。
+
+```
+public void writeList() throws IOException, IndexOutOfBoundsException {
+```
+
+记住 IndexOutOfBoundsException是未检查异常（unchecked exception），包括它在throws子句中不是强制性的。 你可以写成下面这样
+
+```
+public void writeList() throws IOException {
+```