在 Java SE 8 中是否可以使用“带有最终异常的精确重新抛出”？

Question

public class TestException extends except2 {

    public static void main(String[] args)throws Exception  {
       try {
            try {
                throw new TestException();
            }
            catch (final TestException e){         
            }
            throw new except2();
        }
        catch (TestException a){
        }
        catch (Exception e){
            throw e;
        }
    }

    public TestException(){
    }
}

class except2 extends Exception{
}

大家好，

我的 JDK 版本是 8u45，现在是最新版本。

我想知道在 SE 8 中仍然可以使用“带有最终异常的精确重新抛出”吗？

作为代码，如果我将“抛出异常”关闭，它将是编译错误，但根据SE7的“精确重新抛出最终异常”功能应该可以忽略它。

另外一个问题是我们都知道如果嵌套的try box发生了异常，我们还是应该把它扔到外层的catch box来避免编译错误，我本来以为只要抛出任意类型的异常就可以了& 它会做，我的测试结果也是如此，我认为这是让编译器知道 try box 和 catch box 中存在异常也得到了它。

但是如果我像下面的代码一样改变它：

public class TestException extends except2 {
    public static void main(String[] args)throws Exception  {
       try {
            try {
                throw new ArithmeticException();
            } catch (final TestException e){
                throw e;
            } 
        } catch (TestException a){
        } catch (Exception e){
            throw e;
        }
    }
}

(final TestException e) 部分将是编译错误消息：

"com.xxx.TestException" 异常不会在相应的 try 块中抛出",

我很困惑，因为如果嵌套的 catch 块无法处理异常，它应该转到外部。

那么，如果我在外部 try 块的末尾抛出一个 ArithmeticException，如下所示：

try {
    try {
        throw new TestException();
    }
    catch (final TestException e){
        System.out.println("d");
    }

    throw new ArithmeticException();
}
catch (TestException a){
}
catch (Exception e){
    throw e;
}

与外部捕获框catch (TestException a){}相同的错误

为什么会这样？

它应该被(Exception e) 块捕获。

如果我不能从嵌套try块的第一个异常中抛出不同类型的异常，为什么我可以在第一段代码中抛出except2？

Answer 1

这是该功能的 Oracle 示例，它仍然适用于 Java 8：

static class FirstException extends Exception { }
static class SecondException extends Exception { }

public void rethrowException(String exceptionName)
   throws FirstExceptio, SecondException // Since J7 no "Exception" needed
{
  try {
    if (exceptionName.equals("First")) {
      throw new FirstException();
    } else {
      throw new SecondException();
    }
  } catch (Exception e) {
    throw e; // effective final (i.e. not assigned)
  }
}

这在Oracle document 的后半部分进行了描述。您的示例都与它无关。尤其不是你有更具体和普遍的捕捉的那个。这在文档中明确提到不起作用。

如果您使用except2（我将其重命名为BaseException），您的第一个块将起作用，这是更具体的：

public class TestException extends BaseException {

    public static void main(String[] args) {
       try {
            try {
                throw new TestException();
            }
            catch (final BaseException e){
              throw e; // this is defined as BaseEx, will fail on Java 6
            }
        }
        catch (TestException a){ // this knows that no BaseEx is expected
        }
    }

    public TestException(){
    }
}

class BaseException extends Exception { }

如您所见，main() 方法不再需要抛出异常，因为第二个 catch 块就足够了。

Answer 2

您的第一段代码可以缩短为

class TestException extends except2 throws Exception {
    public static void main(String[] args) {
        try {
            throw new except2(); // this
        } catch (TestException a) {
        } catch (Exception e) {
            throw e;
        }
    }

    public TestException() {
    }
}

class except2 extends Exception {
}

你正在抛出一个except2。 TestException 是 except2，但 except2 不一定是 TestException。第一个 catch 块无法处理 except2 异常。所以第二个必须。由于它进一步throws 那个异常，并且必须检查那个异常，你需要有一个throws 子句。

你的第二段代码

class TestException extends except2 {
    public static void main(String[] args) throws Exception {
        try {
            try {
                throw new ArithmeticException();
            } catch (final TestException e) { // nothing above throws a TestException
                throw e;
            }
        } catch (TestException a) {
        }
        catch (Exception e) {

            throw e;
        }
    }
}

正在尝试在嵌套的 try 块中捕获 TestException。但是由于TestException 是一个检查异常，编译器可以并且确实检查它是否可以在该块中抛出。在你的情况下，它不能。所以它抱怨试图抓住它是没有用的。

最后，在你的最后一个sn-p中

class TestException extends except2 {
    public static void main(String[] args) throws Exception {
        try {
            try {
                throw new TestException();
            } catch (final TestException e) {
                System.out.println("d");
            }
            throw new ArithmeticException();
        } catch (TestException a) {
        } catch (Exception e) {
            throw e;
        }
    }
}

您在嵌套的try-catch 语句中抛出和捕获TestException。所以你可以将代码减少到

class TestException extends except2 {
    public static void main(String[] args) throws Exception {
        try {
            throw new ArithmeticException();
        } catch (TestException a) {
        } catch (Exception e) {
            throw e;
        }
    }
}

这与您的第二段代码有相同的问题。那里没有可以抛出TestException的代码路径。

---

关于cmets，为了简化第二个sn-p，误差减少到

class TestException extends except2 {
    public static void main(String[] args) throws Exception {
        try {
            throw new ArithmeticException();
        } catch (final TestException e) { // nothing above throws a TestException
            throw e;
        }
    }
}

你有一个catch(TestException)，但没有抛出一个TestException，所以这是编译器拒绝的无用代码。

---

来自 cmets，这是您的案例 2 和 3 的问题

// ignore everything around this
try {
    // nothing in this block 
    // can throw a TestException

    throw new ArithmeticException();

// this whole catch block is useless code
// Test Exception can never be thrown
} catch (final TestException e){ 
    throw e;
} 
// ignore everything around this