JDK 7通过改进的类型检查捕获多个异常类型并重新引发异常

Question

在Java 7之前，如果我们必须从方法中重新引发异常，那么我们将不得不采用以下两种方法之一，

public void rethrowException(String exceptionName) throws FirstException, SecondException{
    try {
      if (exceptionName.equals("First")) {
        throw new FirstException();
      } else {
        throw new SecondException();
      }
    } catch (FirstExceptione) {
      throw e;
    }catch (SecondException) {
      throw e;
    }
  }

第二个是，

public void rethrowException(String exceptionName) throws Exception {
    try {
      if (exceptionName.equals("First")) {
        throw new FirstException();
      } else {
        throw new SecondException();
      }
    } catch (Exception e) {
      throw e;
    }
  }

根据我的理解，新Java7.0的改进在于，您可以捕获广泛级别的异常，并且仍然将狭义异常保留在方法定义中，就像下面的代码一样，

public void rethrowException(String exceptionName)
  throws FirstException, SecondException {
    try {
      // ...
    }
    catch (Exception e) {
      throw e;
    }
  }

Java SE 7编译器可以确定语句throw e引发的异常必须来自try块，try块引发的唯一异常可以是FirstException和SecondException。即使catch子句的异常参数e是类型exception，编译器也可以确定它是FirstException或SecondException的实例。如果将catch参数指定给catch块中的另一个值，则禁用此分析。但是，如果catch参数被分配给另一个值，则必须在方法声明的throws子句中指定异常类型exception。

从Oracle文档，

具体来说，在Java SE 7及更高版本中，当您在catch子句中声明一个或多个异常类型，并重新发送此catch块处理的异常时，编译器将验证重新发送异常的类型是否满足以下条件：

1) The try block is able to throw it.
2) There are no other preceding catch blocks that can handle it.
3) It is a subtype or supertype of one of the catch clause's exception parameters.
4) In releases prior to Java SE 7, you cannot throw an exception that is a supertype of one of   
the catch clause's exception parameters. A compiler from a release prior to Java SE 7 generates 
the error, "unreported exception Exception; must be caught or declared to be thrown" at the 
statement throw e. The compiler checks if the type of the exception thrown is assignable to any 
of the types declared in the throws clause of the rethrowException method declaration. However, 
the type of the catch parameter e is Exception, which is a supertype, not a subtype, of 
FirstException andSecondException.

我没有从理论上理解第三点和第四点。有人能用上面提到的代码来解释我吗？

Answer 1

考虑以下情况：

应用程序抛出一个异常，即第一个异常、第二个异常、异常

异常是第一异常、第二异常的超类型，因为它们扩展了异常。

它还应该适用于秒异常扩展FirstException。因此FirstException是秒异常的超类型，而秒异常是FirstException的子类型。

现在我们有了一个总是抛出秒异常的方法。

第一种情况：

try {
[...]
} catch(SecondException se) {
// Exception gets always caught in here
[...]
} catch(FirstException fe) {
[...]
} catch(Exception e) {
[...]
}

第二种情况：

try {
[...]
} catch(Exception e) {
// Exception gets always caught in here
// because Exception is supertype of all other Exception
[...]
} catch(FirstException fe) {
[...]
} catch(SecondException se) {
// is never called.
[...]
} 

你明白重点了吗？