Java——异常谜题

1、谜题36  try和finally语句，代码如下，判断输出

public class Indecisive {
    public static void main(String[] args) {
        System.out.println(decision());
    }
    static boolean decision() {
        try {
            return true;
        } finally {
            return false;
        }
    }
}

最后的输出为false，为什么呢？这是因为try的异常结束（例如return，break，continue，throws）是不会影响finally语句块的执行。

2、谜题37 考察try catch的规则掌握程度

public class Arcane1 {
    public static void main(String[] args) {
        try {
            System.out.println("Hello world");
        } catch(IOException e) {
            System.out.println("I've never seen
               println fail!");
        }
    }
}

这段代码看着会编译通过，但是实际上编译都不能通过。这里就考察到被检查异常的一个基本原则。try里的代码println执行IO，但是它不能抛出IOException异常，而catch里检查的异常就是IOException，所以会出现编译不通过。语言规范中描述道：如果一个catch子句要捕获一个类型为E的被检查异常，而其相对应的try子句不能抛出E的某种子类型的异常，那么这就是一个编译期错误[JLS 11.2.3]。

public class Arcane2 {
    public static void main(String[] args) {
        try {
            // If you have nothing nice to say, say nothing
        } catch(Exception e) {
            System.out.println("This can't
                happen");
        }
    }
}

这段代码，如果你看了上面的，你肯定会以为编译不通过，可是他的编译 是通过的。为什么呢？因为Catch里捕捉的是Exception，捕获这个异常在规则里是合法的。尽管是一个合法程序，因为没有触发这个异常，所以catch里仍然不会执行。

interface Type1 {
    void f() throws CloneNotSupportedException;
}

interface Type2 {
    void f() throws InterruptedException;
}

interface Type3 extends Type1, Type2 {
}

public class Arcane3 implements Type3 {
    public void f() {
        System.out.println("Hello world");
    }
    public static void main(String[] args) {
        Type3 t3 = new Arcane3();
        t3.f();
    }
}

每一个接口都限制了方法f可以抛出的被检查异常集合。一个方法可以抛出的被检查异常集合是它所适用的所有类型声明要抛出的被检查异常集合的交集，而不是合集。因此，静态类型为Type3的对象上的f方法根本就不能抛出任何被检查异常。因此，Arcane3可以毫无错误地通过编译，并且打印Hello world。

总之，第一个程序说明了一项基本要求，即对于捕获被检查异常的catch子句，只有在相应的try子句可以抛出这些异常时才被允许。第二个程序说明了这项要求不会应用到的冷僻案例。第三个程序说明了多个继承而来的throws子句的交集，将减少而不是增加方法允许抛出的异常数量。本谜题所说明的行为一般不会引发难以捉摸的bug，但是你第一次看到它们时，可能会有点吃惊。

3、谜题40  不情愿的构造器

构造方法中抛出异常并不常见，下面的代码就是这样，思考下会打印出什么？

public class Reluctant {
    private Reluctant a = new Reluctant();
    public Reluctant() throws Exception {
        throw new Exception("I'm not coming out");
    }
    public static void main(String[] args) {
        try {
            Reluctant b = new Reluctant();
            System.out.println("Surprise!");
        } catch (Exception ex) {
            System.out.println("I told you so");
        }
    }
}

运行之后，什么也没打印，报错误——StackOverflowError异常（属于Error，不属于Exception，所以catch不能捕捉）。为什么呢？这是因为，当你调用构造器时，实例化变量的初始化操作会先于构造器的程序体运行。在上述代码中，a变量的初始化调用了构造器，而构造器需要调用自身去完成初始化操作，所以就造成了一个递归。

对于一个对象包含与它自己类型相同的实例的情况，并不少见。例如，链接列表节点、树节点和图节点都属于这种情况。你必须非常小心地初始化这样的包含实例，以避免StackOverflowError异常。

总之，实例初始化操作是先于构造器的程序体而运行的。实例初始化操作抛出的任何异常都会传播给构造器。最后，对于我们所设计的类，如果其实例包含同样属于这个类的其他实例，那么对这种无限递归要格外当心。

4、谜题41 域和流

这个想给的结论就是：当你在finally语句块中调用close方法时，要用一个嵌套的try-catch语句来保护它，以防止IOException的传播。更一般地讲，对于任何在finally语句块中可能会抛出的被检查异常都要进行处理，而不是任其传播。

5、操作符

逻辑AND操作符&   条件AND操作符&& 区别：前者必须计算两个操作数之间的与关系     后者当前边的操作数为false时，就直接返回false，不在考虑后边操作数的真假。

逻辑OR操作符|     条件OR操作符||   区别：前者必须计算两个操作数之间的或关系  后者当前边的操作数为true时，就直接返回true，不考虑后边的。