为什么在某些情况下不声明而重新抛出Throwable是合法的？

Question

我希望下面的代码在上引发编译时错误throw t;，因为main未声明为throw Throwable，但编译成功（在Java
1.7.0_45中），并且如果编译时错误为，则会生成您期望的输出固定。

public class Test {
    public static void main(String[] args) {
        try {
            throw new NullPointerException();

        } catch(Throwable t) {
            System.out.println("Caught "+t);
            throw t;
        }
    }
}

如果Throwable更改为，它也会编译Exception。

不会按预期方式编译：

public class Test {
    public static void main(String[] args) {
        try {
            throw new NullPointerException();

        } catch(Throwable t) {
            Throwable t2 = t;
            System.out.println("Caught "+t2);
            throw t2;
        }
    }
}

这样编译：

public class Test {
    public static void main(String[] args) {
        try {
            throwsRuntimeException();

        } catch(Throwable t) {
            System.out.println("Caught "+t);
            throw t;
        }
    }

    public static void throwsRuntimeException() {
        throw new NullPointerException();
    }
}

这不是：

public class Test {
    public static void main(String[] args) {
        try {
            throwsCheckedException();

        } catch(Throwable t) {
            System.out.println("Caught "+t);
            throw t;
        }
    }

    public static void throwsCheckedException() {
        throw new java.io.IOException();
    }
}

这也可以编译：

public class Test {
    public static void main(String[] args) throws java.io.IOException {
        try {
            throwsIOException();

        } catch(Throwable t) {
            System.out.println("Caught "+t);
            throw t;
        }
    }

    public static void throwsIOException() throws java.io.IOException {
        throw new java.io.IOException();
    }
}

一个更复杂的示例-被检查的异常由外部catch块捕获，而不是被声明为抛出。这样编译：

public class Test {
    public static void main(String[] args) {
        try {
            try {
                throwsIOException();

            } catch(Throwable t) {
                System.out.println("Caught "+t);
                throw t;
            }
        } catch(java.io.IOException e) {
            System.out.println("Caught IOException (outer block)");
        }
    }

    public static void throwsIOException() throws java.io.IOException {
        throw new java.io.IOException();
    }
}

因此，当编译器可以确定捕获的异常始终合法地重新抛出时，似乎有一种特殊情况允许重新抛出异常。这样对吗？JLS在哪里指定？还有其他类似的晦涩难解案例吗？

Answer 1

JLS
11.2.2
（重点是我）对此进行了介绍：

如果throw语句的抛出表达式是 catch子句C 的最终或有效的最终 异常参数 ，则可以抛出异常类E iff：

• E是一个异常类，声明C的try语句的try块可以抛出该异常类；和

• E是与C的任何可捕获异常类兼容的分配 ；和

（…）

换句话说，Edoc中引用的类型 是可以抛出 的类型，而不是捕获它的catch子句参数的类型（ catchable异常类 ）。它只需要在 分配
上与catch子句参数 兼容 ，但是在分析中不使用该参数的类型。

这就是为什么竭尽全力说出 最终或有效的最终异常参数的 原因-如果t在您的示例中重新分配了 异常 ，则分析将超出预期范围。