在Java7之前，我们必须把所有IO操作放入try-catch-finally块中。当IO操作出现异常时，finally里必须关闭流。代码使用演示：

    1. public class HandleException1 {
    2.     public static void main(String[] args) {
    3.           // 声明变量
    4.         FileWriter fw = null;
    5.         try {
    6.             //创建流对象
    7.             fw = new FileWriter("fw.txt");
    8.             // 写出数据
    9.             fw.write("黑马程序员"); //黑马程序员
    10.         } catch (IOException e) {
    11.             e.printStackTrace();
    12.         } finally {
    13.             try {
    14.                 if (fw != null) {
    15.                     fw.close();
    16.                 }
    17.             } catch (IOException e) {
    18.                 e.printStackTrace();
    19.             }
    20.         }
    21.     }
    22. }

    Java 7 引入了一个语法糖，确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。
    格式：

    1. try (创建流对象语句，如果多个,使用';'隔开) {
    2.     // 读写数据
    3. } catch (IOException e) {
    4.     e.printStackTrace();
    5. }

    代码使用演示：

    1. public class HandleException2 {
    2.     public static void main(String[] args) {
    3.           // 创建流对象
    4.         try ( FileWriter fw = new FileWriter("fw.txt"); ) {
    5.             // 写出数据
    6.             fw.write("黑马程序员"); //黑马程序员
    7.         } catch (IOException e) {
    8.             e.printStackTrace();
    9.         }
    10.     }
    11. }

    Java 9中对这个语法糖进行了进一步改进：

    1. // 被final修饰的对象
    2. final Resource resource1 = new Resource("resource1");
    3. // 普通对象
    4. Resource resource2 = new Resource("resource2");
    6. // 引入方式：直接引入
    7. try (resource1; resource2) {
    8.      // 使用对象
    9. }