是否需要抛出异常而抛出异常? [英] Rethrowing Exception without requiring throws Exception?

问题描述

考虑以下代码:

static void main(String[] args) {
  try {
  } catch (Exception e) {
    throw e;
  }
}

此代码可以编译，而无需在方法签名中添加 throws异常.(它与 Throwable 代替 Exception 的行为类似).

This code compiles without having to add throws Exception to the method signature. (It behaves similarly with Throwable in place of Exception, too).

我理解为什么 可以安全运行，因为实际上 try 块中不会抛出 Exception 不能抛出异常；我想知道在哪里指定了此行为.

I understand why it can be run safely, in that Exception can't actually be thrown in the try block, so a checked exception cannot be thrown; I'm interested to know where this behaviour is specified.

并非仅仅没有达到 throw e :以下代码也可以编译:

It's not simply that the throw e is never reached: the following code also compiles:

static void stillCompilesWithThrownUncheckedException() {
  try {
    throw new NullPointerException();
  } catch (Exception e) {
    throw e;
  }
}

但是，如果抛出一个检查的异常，它不会像我期望的那样编译:

But if you throw a checked exception, it doesn't compile, as I expect:

static void doesNotCompileWithThrownCheckedException() {
  try {
    throw new Exception();
  } catch (Exception e) {
    throw e;  // error: unreported exception Exception; must be caught or declared to be thrown
  }
}

在 JLS Sec 11.2中.2 ，它说:

一个 throw 语句(第14.18节)，其引发的表达式具有静态类型E，并且不是最终或有效的最终异常参数，可以引发E或引发的表达式可以引发的任何异常类.>

A throw statement (§14.18) whose thrown expression has static type E and is not a final or effectively final exception parameter can throw E or any exception class that the thrown expression can throw.

我对此声明的解释是， e 可以引发 Exception ，因为 e 的静态类型是 Exception .然后，在 JLS Sec 11.2.3 :

My interpretation of this statement is that throw e can throw Exception, because the static type of e is Exception. And then, in JLS Sec 11.2.3:

当E是检查的异常类并且E不是方法或构造函数的throws子句中声明的某个类的子类时，如果方法或构造函数主体可以抛出某些异常类E，则是编译时错误./p>

It is a compile-time error if a method or constructor body can throw some exception class E when E is a checked exception class and E is not a subclass of some class declared in the throws clause of the method or constructor.

但这不是前两种情况下的编译时错误.语言规范在哪里描述了这种行为?

But it's not a compile-time error in the first two cases. Where is this behavior described in the language spec?

将其标记为重复，我要问一个后续问题:为什么不 throw e; 在第一个示例中被认为不可达.

having marked it a dupe, I was going to ask the follow-up question: why isn't throw e; considered unreachable in the first example.

在

• 如果满足以下两个条件，则可以到达捕获块C:

  • A catch block C is reachable iff both of the following are true:

  • C的参数类型是未经检查的异常类型或Exception，或者是Exception的超类，或者try块中的某些表达式或throw语句可以到达，并且可以抛出其类型可分配给该类型的经检查的异常C的参数.(如果包含表达式的最里面的语句是可到达的，则该表达式是可到达的.)

  • Either the type of C's parameter is an unchecked exception type or Exception or a superclass of Exception, or some expression or throw statement in the try block is reachable and can throw a checked exception whose type is assignable to the type of C's parameter. (An expression is reachable iff the innermost statement containing it is reachable.)

  有关表达式的正常和突然完成，请参见§15.6.

  See §15.6 for normal and abrupt completion of expressions.

  在try语句中没有较早的catch块A，以使C的参数类型与A的参数相同或为A的子类.

  There is no earlier catch block A in the try statement such that the type of C's parameter is the same as or a subclass of the type of A's parameter.

  这两个都是正确的(其类型为 Exception ，并且没有较早的catch块)，因此它是可到达的".我猜想作为特殊情况，调用空的 try 块对于这种边际使用的构造来说实在太大了.

  Both of these are true (it's of type Exception, and there's no earlier catch block), so it's "reachable". I guess the effort of calling out an empty try block as a special case was too great for such a marginally-useful construct.

  推荐答案

  我相信第11.2.2节的下一段会回答以下问题:

  I believe the very next paragraph of section 11.2.2 answers the question:

  一条 throw 语句，其引发的表达式是 catch 子句C的最终或有效的最终异常参数，可以引发异常类E iff:

  A throw statement whose thrown expression is a final or effectively final exception parameter of a catch clause C can throw an exception class E iff:

  • E是一个异常类，声明C的 try 语句的 try 块可以抛出该异常；和
  • …
  • E is an exception class that the try block of the try statement which declares C can throw; and
  • …

  因此， throw e; 仅可以抛出相应try块可以抛出"的异常，后者由try块中的实际语句定义.

  So, throw e; "can throw" only exceptions which the corresponding try-block "can throw," where the latter is defined by the actual statements in the try-block.

  很显然，空的try-block不符合任何异常类的可抛出"部分的条件.您的第二个示例可以抛出" NullPointerException，并且由于catch块只能抛出try块可以抛出"的异常，因此catch块也只能抛出未经检查的NullPointerException.

  Obviously an empty try-block does not qualify as a "can throw" section for any exception class. Your second example "can throw" NullPointerException, and since the catch-block "can throw" only the exception that the try-block "can throw," the catch-block too can throw only the unchecked NullPointerException.

  您的第三个示例的try块可以抛出" java.lang.Exception本身，因此catch块可以抛出" java.lang.Exception，因此必须捕获或声明要抛出java.lang.Exception.

  Your third example’s try-block "can throw" java.lang.Exception itself, therefore the catch-block "can throw" java.lang.Exception, so java.lang.Exception must be caught or declared to be thrown.

  这篇关于是否需要抛出异常而抛出异常?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！