为什么 Exception.fillInStackTrace 返回 Throwable？

Question

我认为 Exception.fillInStackTrace 应该返回 Exception 或派生的 Exception 对象。考虑下面的两个函数，

public static void f() throws Throwable {
    try {
        throw new Throwable();
    } catch (Exception e) {
        System.out.println("catch exception e");
        e.printStackTrace();
    } 
}
public static void g() throws Throwable {
    try {
        try {
            throw new Exception("exception");
        } catch (Exception e) {
            System.out.println("inner exception handler");
            throw e.fillInStackTrace();
        }
    } catch (Exception e) {
        System.out.println("outer exception handler");
        e.printStackTrace();
    }
}

1. 异常处理程序无法捕获第一个函数f()中的new Throwable()。
2. 异常处理程序可以捕获第二个函数g()中的e.fillInstackTrace()。
3. 但第二个函数 g() 仍然需要抛出 Throwable。这真的很奇怪，因为我们可以捕获e.fillInstackTrace()。

所以我的问题是为什么 Exception.fillInStackTrace 不返回异常或异常派生而不是开发如此奇怪的语法？

编辑：
为了澄清我的问题：我所说的“奇怪的语法”是什么意思是

1. 因为Exception.fillInStackTrace()返回Throwable引用，接收的异常处理程序Exception引用不应该能够捕获异常。因为java不允许隐式向下转换，所以它应该类似于return (Exception)e.fillInstackTrace()。
2. 由于设计时接收 Exception 引用的异常处理程序可以处理 Throwable 异常，因此无需标记方法 g() throws Throwable 异常。但是java编译器会强制我们这样做。

谢谢。

Answer 1

我对你的问题比较困惑。显然有一些关于java异常/异常处理的东西你不明白。那么让我们从头开始吧。

在 java 中，所有异常（在 Java 语言规范中使用该术语的意义上）都是某个类的实例，该类是 java.lang.Throwable 的子类。 Throwable 有两个（而且只有两个）直接子类；即java.lang.Exception和java.lang.Error。所有这些类的实例...包括 Throwable 和 Error 的实例...在 JLS 中被称为异常。

异常处理程序捕获与 catch 声明中使用的异常类型分配兼容的异常（在 JLS 意义上）。例如：

try {
    ....
} catch (Exception ex) {
    ...
}

将捕获 try 块中抛出的任何异常，该异常是 java.lang.Exception 的实例或 java 的直接或间接子类型的实例。 lang.Exception。但它不会捕获 java.lang.Throwable 的实例，因为（显然）它不是上述之一。

另一方面：

try {
    ....
} catch (Throwable ex) {
    ...
}

将捕获java.lang.Throwable的实例。

根据这一点回顾您的示例，很明显为什么 f 方法没有捕获 Throwable 实例：它与 catch 子句中的异常类型不匹配！相比之下，在 g 方法中，Exception 实例与 catch 子句中的异常类型匹配，因此被捕获。

我不明白你所说的需要在 g 中抛出 Throwable 是什么意思。首先，该方法声明它抛出 Throwable 的事实并不意味着它实际上需要抛出它。它所说的只是它可能抛出一些可分配给Throwable的东西......可能在g方法的某个未来版本中。其次，如果您将 throw e; 添加到外部 catch 块，那么它会抛出可分配给 Throwable 的内容。

最后，创建 Throwable、Exception、Error 和 RuntimeException 的实例通常是一个坏主意。你需要非常小心何时以及如何捕捉它们。例如：

try {
     // throws an IOException if file is missing
    InputStream is = new FileInputStream("someFile.txt");
    // do other stuff
} catch (Exception ex) {
    System.err.println("File not found");
    // WRONG!!!  We might have caught some completely unrelated exception;
    // e.g. a NullPointerException, StackOverflowError, 
}

编辑 - 回应OP的评论：

但是我用 throw e.fillInStackTrace(); 抛出了什么；应该是 Throwable 实例，而不是异常！

Javadoc 特别指出，返回的对象是您正在调用该方法的异常对象。 fillInStacktrace() 方法的用途是填充现有对象的堆栈跟踪。如果您想要不同的异常，则应该使用 new 创建一个。

实际上，我的意思是外部异常处理程序不应该捕获由 throw e.fillInStackTrace() 抛出的 Throwable。

我已经解释了为什么会这样 - 因为 Throwable 实际上是原始的异常。我的解释是否有您不理解的地方，或者您只是说您不喜欢 Java 的定义方式？

编辑2

如果外部异常处理程序可以处理 Throwable 异常，为什么我们必须指定方法 g 抛出 Throwable 异常

您误解了我的意思...也就是说，如果您确实抛出了 Exception，那么 会抛出 Throwable 不会是多余的。 OTOH，我终于想我理解你的抱怨了。

我认为你抱怨的关键是你会得到一个编译错误：

public void function() throws Exception {
    try {
        throw new Exception();
    } catch (Exception ex) {
        throw ex.fillInStackTrace();
        // according to the static type checker, the above throws a Throwable
        // which has to be caught, or declared as thrown.  But we "know" that the 
        // exception cannot be anything other than an Exception.
    }
}

我可以看到这有点出乎意料。但这恐怕是不可避免的。没有任何方法（除非对 Java 类型系统进行重大更改）可以声明适用于所有情况的 fillInStacktrace 签名。例如，如果将方法的声明移至 Exception 类，则只需对 Exception 的子类型重复相同的问题。但是，如果您尝试使用泛型类型参数来表达签名，则需要创建 Throwable 显式泛型类型的所有子类。

幸运的是，治疗方法非常简单；将 fillInStacktrace() 的结果转换如下：

public void function() throws Exception {
    try {
        throw new Exception();
    } catch (Exception ex) {
        throw (Exception) (ex.fillInStackTrace());
    }
}

最后一点是，应用程序显式调用 fillInStacktrace() 的情况非常罕见。鉴于此，Java 设计者“绞尽脑汁”试图解决这个问题根本不值得。特别是因为这实际上只是一个小小的不便......最多。

Answer 2

实际上从问题 2 开始回答你的问题更容易。

你问：
2. 由于设计时接收 Exception 引用的异常处理程序可以处理 Throwable 异常，因此不需要标记方法 g() throws Throwable 异常。但是 java 编译器会强制我们这样做。

回答：
实际上，catch(Exception e) 无法捕获 Throwable。
试试这个：

try {
       Throwable t = new Throwable();
       throw t.fillInStackTrace();
} catch (Exception e) {
    System.out.println("outer exception handler");
    e.printStackTrace();
} 

您会看到在这种情况下 catch 子句没有捕获 throw。

catch 子句在 g() 方法中起作用的原因是，当您调用 throw e.fillInStackTrace() 时，对 fillInStackTrace 的调用实际上返回一个 Exception（这是因为 e 本身就是一个 Exception）。由于 Exception 是 Throwable 的子类，因此这与 fillInStackTrace 的声明并不矛盾。

现在回答

您提出的第一个问题：
1. 由于 Exception.fillInStackTrace() 返回 Throwable 引用，因此接收 Exception 引用的异常处理程序不应该能够捕获该异常。因为 java 不允许隐式向下转型，所以应该类似​​于 return (Exception)e.fillInstackTrace() 。

回答：
这并不完全是一种隐含的沮丧。将此视为重载的一种变体。

假设

void process(Throwable t){
   ...
}
void process(Exception e){
  ...
} 

您调用了 process(someObject)，它将在运行时确定是调用第一个还是第二个 process 方法。同样，catch(Exception e) 子句是否可以捕获您的 throw 将在运行时根据您抛出的是 Exception 还是 Throwable 来确定。

Answer 3

我认为您必须询问 Frank Yellin（java.lang.Exception 的 @author）。正如其他人所说， fillInStackTrace() 在 Throwable 中声明，并记录为返回 this，因此它的返回类型必须是 Throwable< /代码>。它只是被Exception继承。 Frank 可以在 Exception 中重写它，如下所示：

public class Exception extends Throwable{
    /**Narrows the type of the overridden method*/
    @Override
    public synchronized Exception fillInStackTrace() {
        super.fillInStackTrace();
        return this;
    }
}

...但他没有。在Java 1.5之前，原因是它会产生编译错误。在 1.5 及更高版本中，允许使用协变返回类型，并且上述内容是合法的。

但我的猜测是，如果上述覆盖存在，那么您会问为什么 RuntimeException 没有类似的覆盖，为什么 ArrayStoreException 没有覆盖该覆盖，等等。因此，弗兰克和朋友们可能只是不想编写数百个相同的覆盖。

值得注意的是，如果您正在处理自己的自定义异常类，您可以轻松地重写 fillinStackTrace() 方法，就像我上面所做的那样，并获得您想要的更窄的类型。

使用泛型，人们可以想象将 Throwable 的声明增强为：

public class Throwable<T extends Throwable<T>>{
    public synchronized native T fillInStackTrace();
}

...但这并不真正令人满意，原因超出了本答案的范围。

Answer 4

fillInStackTrace 返回对同一对象的引用。它的方法链接允许重新抛出异常并重置异常的堆栈跟踪。

public static void m() {
    throw new RuntimeException();

}

public static void main(String[] args) throws Throwable {
    try {
        m();
    } catch (Exception e) {
        e.printStackTrace();
        throw e.fillInStackTrace();
    }
}

方法返回类型只能是基类型，即Throwable。可以对其进行泛化，以便该方法返回参数化类型。但目前情况并非如此。

RuntimeException e = new RuntimeException();
Throwable e1 = e.fillInStackTrace();
System.out.println(e1.getClass().getName()); //prints java.lang.RuntimeException
System.out.println(e == e1); //prints true

Answer 5

fillInStackTrace() 由 Throwable 定义，而不是 Exception。

并非所有 Throwable 的子类都是异常（例如 Error）。就 Throwable 而言，它唯一能保证 fillInStackTrace() 的返回值的是它是 Throwable 的实例（因为它只返回相同的对象，正如 Chandra Patni 指出的那样）。

Answer 6

实际上，fillInStackTrace 返回调用它的同一个对象。

e.fillInStackTrace == e 始终为 true

这只是一个快捷方式，您也可以编写

    } catch (Exception e) {
        System.out.println("inner exception handler");
        e.fillInStackTrace();
        throw e;
    }

或使用强制转换

    throw (Exception) e.fillInStackTrace();

BTW，initCause() 也会发生同样的情况。