初识Java 13-3 异常

最新推荐文章于 2024-07-13 22:56:10 发布

w_pab

最新推荐文章于 2024-07-13 22:56:10 发布

阅读量143

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/w_pab/article/details/133791463

版权

Java 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

try-with-resources语句

一些细节

新特性：try-with-resources中的实际变量

本笔记参考自：《On Java 中文版》

try-with-resources语句

层层叠叠的异常很容易让人看花眼，要确保每一条可能存在的故障路径无疑是一项巨大的挑战。在之前提到的InputFile.java就是一个反面教材。

可以改进InputFile：①将文件相关的操作（打开、读取和关闭）集中在构造器中，或是②使用Stream进行操作。

【例子：优化InputFile】

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class InputFile2 {
    private String fname;

    public InputFile2(String fname) {
        this.fname = fname;
    }

    public Stream<String> getLines()
            throws IOException {
        return Files.lines(Paths.get(fname));
    }

    public static void main(String[] args)
            throws IOException {
        new InputFile2("InputFile2.java").getLines()
                .skip(14)
                .limit(1)
                .forEach(System.out::println);
    }
}

程序执行的结果是：

在上述代码中，getLines()只需要负责打开文件并创建流。

但实际上，这种问题并没有这么好回避。总是会有对象出乎我们的意料，这些对象往往需要在特定的时刻进行清理（比如走出某个作用域的时候）。

【例子：麻烦的异常处理】

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class MessyExceptions {
    public static void main(String[] args) {
        InputStream in = null;
        try {
            in = new FileInputStream(new File("MessyExceptions.java"));
            int contents = in.read();
            // 对内容进行操作
        } catch (IOException e) {
            // 处理错误
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    // close()可能报错，需要处理它
                }
            }
        }
    }
}

当我们终于进入了finally块，却发现自己可能还需要继续处理更多的异常。这就会让事情变得过于复杂。

为了简化这种重复的工作，Java 7引入了try-with-resources语法：

【例子：try-with-resources的使用例】

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class TryWithResources {
    public static void main(String[] args) {
        try (
                InputStream in = new FileInputStream(
                        new File("TryWithResources.java"));
        ) {
            int contents = in.read();
            // 进行各种操作
        } catch (IOException e) {
            // 处理错误
        }
    }
}

上述的try语法和之前有所不同，出现了一个()：

括号中的内容叫做资源说明头，其中in的作用域是整个try块（包括下面的catch子句）。

更重要的是，在try-with-resources定义子句（即括号内）创建的对象必须实现java.lang.AutoCloseable接口，这个接口只有一个方法 —— close()。现在无论如何退出try块，都会执行操作in.close()，这就缩减了原本复杂的代码。

【例子：try-with-resources的使用例2】

import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class StreamsAreAutoCloseable {
    public static void main(String[] args)
            throws IOException {
        try ( // 资源头可以包含多个定义，不同定义之间用分号隔开
                Stream<String> in = Files.lines(
                        Paths.get("StreamsAreAutoCloseable.java"));
                PrintWriter outfile = new PrintWriter("Results.txt");
        ) {
            in.skip(4)
                    .limit(1)
                    .map(String::toLowerCase)
                    .forEach(System.out::println);
        }
    }
}

在资源头中定义的每个对象，它们都会在try块的末尾调用对应的close()。

上述程序中，try块并没有对应的catch子句进行异常处理。这是因为IOException会直接通过main()传递出去，这就使得这一异常不需要在try块的末尾进行捕捉了。

顺便一提，Java 5实现的Closeable类后来也继承了AutoCloseable类。因此任何支持Closeable的对象也可以配合try-with-resources进行使用。

一些细节

可以创建自己的AutoCloseable类，来研究try-with-resources的底层机制：

class Reporter implements AutoCloseable {
    String name = getClass().getSimpleName();

    Reporter() {
        System.out.println("创建: " + name);
    }

    @Override
    public void close() {
        System.out.println("关闭: " + name);
    }
}

class First extends Reporter {
}

class Second extends Reporter {
}

public class AutoCloseableDetails {
    public static void main(String[] args) {
        try (
                First f = new First();
                Second s = new Second();
        ) {
        }
    }
}

程序执行的结果是：

在退出try块时，调用了两个对象的close()方法。由输出可以发现，会以和创建顺序相反的顺序关闭它们。这么做是考虑到不同的对象之间可能存在着依赖关系。

若某个类没有实现AutoCloseable接口，就会引发报错：

另外，让我们再来看看构造器报错的情况：

【例子：构造器报错（在资源说明头中抛出异常）】

class CE extends Exception {
}

class SecondExcept extends Reporter {
    SecondExcept() throws CE {
        super();
        throw new CE();
    }
}

public class ConstructorException {
    public static void main(String[] args) {
        try (
                First f = new First();
                SecondExcept s = new SecondExcept();
                Second s2 = new Second();
        ) {
            System.out.println("在try块的内部");
        } catch (CE e) {
            System.out.println("捕获异常：" + e);
        }
    }
}

程序执行的结果是：

因为语句SecondExcept s = new SecondExcept();会抛出异常，所以编译器会强制要求我们提供一个catch子句来捕获它。这侧面反映了资源说明头实际上是被try块包围的。

仔细观察可以发现，SecondExcept的close()方法并没有被调用。这是因为构造已经失败了，我们无法假定在其上进行的任何操作是安全的。

------

【例子：在try块中抛出异常】

class Third extends Reporter {
}

public class BodyException {
    public static void main(String[] args) {
        try (
                First f = new First();
                Second s2 = new Second();
        ) {
            System.out.println("在try块中");
            Third t = new Third();
            new SecondExcept(); // 会抛出异常
            System.out.println("try块结束");
        } catch (CE e) {
            System.out.println("捕获异常：" + e);
        }
    }
}

程序执行的结果是：

注意：上述程序中的Third对象永远不会得到清理，因为它不是在资源说明头中进行创建的。

实际上，若是依赖于某个集成开发环境将代码重写为try-with-resources的形式，它们有可能只会保护所遇到的第一个对象，而忽略其他的对象。

------

【例子：close()抛出异常】

class CloseException extends Exception {
}

class Reporter2 implements AutoCloseable {
    String name = getClass().getSimpleName();

    Reporter2() {
        System.out.println("创建：" + name);
    }

    @Override
    public void close() throws CloseException {
        System.out.println("关闭：" + name);
    }
}

class Closer extends Reporter2 {
    @Override
    public void close() throws CloseException {
        super.close();
        throw new CloseException();
    }
}

public class CloseExceptions {
    public static void main(String[] args) {
        try (
                First f = new First();
                Closer c = new Closer();
                Second s = new Second();
        ) {
            System.out.println("在try块中");
        } catch (CloseException e) {
            System.out.println("捕获异常：" + e);
        }
    }
}

程序执行的结果是：

一个好的习惯是将错误处理代码放置在catch子句中。

在这里，三个对象按照顺序创建，并且按照相反的顺序关闭，即使Closer.close()会抛出异常。

新特性：try-with-resources中的实际变量

最初，try-with-resources中的所有被管理的变量都需要被定义在资源说明头中。但从JDK 9开始，这些被管理的变量也可以被定义在try之前，只要它们是最终变量（或是实际上的最终变量）。

【例子：对比新旧语法】

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class EffectivelyFinalTWR {
    static void old() {
        try (
                InputStream r1 = new FileInputStream(
                        new File("InputFile2.java"));
                InputStream r2 = new FileInputStream(
                        new File("EffectivelyFinalTWR.java"))
        ) {
            r1.read();
            r2.read();
        } catch (IOException e) {
            // 处理异常
        }
    }

    static void jdk9() throws IOException {
        // 最终变量
        final InputStream r1 = new FileInputStream(
                new File("InputFile2.java"));
        // 实际上的最终变量
        final InputStream r2 = new FileInputStream(
                new File("EffectivelyFinalTWR.java"));
        try (r1; r2) { // 将变量放入资源说明头
            r1.read();
            r2.read();
        } catch (IOException e) {
            System.out.println("在jdk9内部捕获异常：" + e);
        }

        // 此时r1和r2都被关闭
        // 但r1和r2还存在于作用域中，访问其中的任何一个都会引发异常
        r1.read();
        r2.read();
    }

    public static void main(String[] args) {
        old();
        try {
            jdk9();
        } catch (IOException e) {
            System.out.println("捕获异常：" + e);
        }
    }
}

程序执行的结果是：

jdk9()会把异常传递出来。这个特性无法捕获异常，所以它看起来不怎么可信。

异常匹配

当一个异常被抛出的时候，异常处理系统会按照处理程序的编写顺序寻找能够匹配异常的那个。当找到第一个匹配的处理程序时，系统会认为异常得到了处理，就不会进一步进行搜索了。

匹配异常不会要求完全匹配，子类的对象可以匹配其基类的处理程序：

【例子：异常匹配】

class Annoyance extends Exception {
}

class Sneeze extends Annoyance {
}

public class Human {
    public static void main(String[] args) {
        // 捕获精确的类型：
        try {
            throw new Sneeze();
        } catch (Sneeze s) {
            System.out.println("捕获异常，来自Sneeze");
        } catch (Annoyance a) {
            System.out.println("捕获异常，来自Annoyance");
        }

        // 捕获基类类型：
        try {
            throw new Sneeze();
        } catch (Annoyance a) {
            System.out.println("捕获异常，来自Annoyance");
        }
    }
}

程序执行的结果是：

上述代码中，catch (Annoyance a)将捕获Annoyance或者任何派生自它的类。

另外，若将基类异常的catch子句放在前面，子类的异常就永远无法被触发：

其他可选方式

异常处理允许我们的程序放弃正常语句序列的执行。但若需要处理每个调用可能产生的错误，就会显得过于繁琐。程序员不会这么做，但这会导致错误被忽略。注意，便于程序员处理错误是异常处理的主要动机之一。

异常处理有一个重要准则：除非知道怎么处理，否则不要捕获异常。

另外，通过允许一个处理程序应付多个出错点，异常往往也能减少错误处理的代码量。但检查型异常会使得这种情况变得更加复杂，因为它可能会强迫我们在无法处理错误的地方添加catch子句，这就会造成“吞食有害”：

try {
    // ...（一些有用的操作）
} catch(ObligatoryException e) {} // 强制性的异常处理

程序员往往只做最简单的事情，这就会造成在无意间“吞食”了异常。编译通过，此时除非进行复查并修正代码，否则异常就相当于丢失了。

一种处理方式是在处理程序中打印栈轨迹信息。尽管这种做法可以追踪异常，但这也表明我们没有真正理解如何在这个位置处理这个异常。

||| 格言：所有的模型都是错误的，但有些是有用的。

在评价Java的检查型异常时，应该牢记：这种异常应该能够引导程序员以更好的方式处理错误，并且不会增加太多的代码量。

检查型异常的一些观点

检查型异常是Java的一种尝试，实际上之后的编程语言也没有采用这种做法。

检查型异常或许能够在小型的程序中展示出其的妙用。但随着程序规模的增大，这种情况就会有所变化。有些语言可能不会适合大型项目，但却适合与小型项目。在增大的项目中，增多的检查型异常是难以控制的。

甚至有一种结论：在大型软件项目中，要求异常说明带来的结果是开发效率的降低，和代码质量几乎没有提高。

链式异常的使用

检查型异常的麻烦是需要解决的。这里有一种简单的解决方案，将一个检查型异常传递给RuntimeException构造器，就可以将这个异常包裹在RuntimeException中：

try {
    // ... 有用的处理
} catch(IDontKnowWhatToDoWithThisCheckedException e) {
    throw new RuntimeException(e); // 将e包裹进去，变成非检查型异常
}

由于异常链的存在，我们不会丢失任何来自原始异常的信息。

这使得我们有了选择：忽略这个异常，使其传递到更上层的上下文中；或者使用getCause()捕获和处理特定的异常。

【例子：异常链的使用】

import java.io.FileNotFoundException;
import java.io.IOException;

class WrapCheckedException {
    void throwRuntimeException(int type) {
        try {
            switch (type) {
                case 0:
                    throw new FileNotFoundException();
                case 1:
                    throw new IOException();
                case 2:
                    throw new RuntimeException("不断移动的RuntimeException异常");
                default:
                    return;
            }
        } catch (IOException | RuntimeException e) {
            throw new RuntimeException(e); // 将检查型异常处理成非检查型异常
        }
    }
}

class SomeOtherException extends Exception {
}

public class TurnOffChecking {
    public static void main(String[] args) {
        WrapCheckedException wce = new WrapCheckedException();

        // 这里可以不使用try块
        // 通过直接调用throwRuntumeException()，可以让RuntimeException离开这个方法
        wce.throwRuntimeException(3);

        // 也可以选择捕获该异常：
        for (int i = 0; i < 4; i++) {
            try {
                if (i < 3)
                    wce.throwRuntimeException(i);
                else
                    throw new SomeOtherException();
            } catch (SomeOtherException e) {
                System.out.println(
                        "捕获异常SomeOtherException: " + e);
            } catch (RuntimeException re) {
                try {
                    throw re.getCause();
                } catch (FileNotFoundException e) {
                    System.out.println("捕获异常FileNotFoundException: " + e);
                } catch (IOException e) {
                    System.out.println("捕获异常IOException: " + e);
                } catch (Throwable e) {
                    System.out.println("捕获异常Throwable: " + e);
                }
            }
        }
    }
}

程序执行的结果是：