Question

我了解了嵌套的try-catch语句，我不禁想知道使用嵌套的try的实际意义是什么？内部try的内容已经在外部try中，如果要捕获异常，外部try-catch将对其进行处理。那么为什么要使用内部try？

例如：

代码1：

try 
{
    Statement A;
    Statement B;
    try
    {
        Statement C;
        Statement D;
    }
    catch(CException e) { ... }
    catch(DException e) { ... }
}
catch(AException e) { ... }
catch(BException e) { ... }

代码2：

try 
{
    Statement A;
    Statement B;

    Statement C;
    Statement D;
}
catch(AException e) { ... }
catch(BException e) { ... }
catch(CException e) { ... }
catch(DException e) { ... }

如果我错了，请纠正我，但是上面的这两个代码段不能执行相同的任务吗？

Answer 1

您可以在内部try周围有一个循环，以多次捕获异常而不会退出循环。

try {
    for (int i = 0; i < 10; i++) {
        try {
            someOperationThatOftenFails();
        } catch (SomeCommonException e) {
            ...
        }
    }
} catch (SomeRareFatalException e) {
    ...
}

在这种情况下，嵌套try块是多次捕获SomeCommonException而不退出循环的唯一方法，而且还会导致SomeRareFatalException第一次出现时退出循环。

Answer 2

是的，您碰巧给出的代码片段的行为相同。现在考虑

try 
{
    Statement A;
    Statement B;
    try
    {
        Statement C;
        Statement D;
    }
    catch(CException e) { ... }
    catch(DException e) { ... }

    Statement E;
    Statement F;
}
catch(AException e) { ... }
catch(BException e) { ... }

E和F将被执行而与C和D的结果无关。您将如何尝试一次？（可能的答案：将E / F代码块复制到相关的catch块中。不是很优雅。）

引发的异常的 full 语义不仅是其类型（/ class），而且还是引发异常的代码中的位置。范围很重要。

Answer 3

不完全是。

如果您在同一级别捕获到异常，那么当代码抛出第一个指令时，您将无法执行其他指令。

并非所有例外都是一样的，您应该以一种特定的方式对待每个例外。

有些只需要记录发生的事情，然后继续执行代码即可。

其他时间，您不能继续停下来。

存在异常的原因是为了能够在适当的级别上处理错误。

例如，您可以在方法的签名中放入代码可能引发异常的签名，因此调用者必须处理此类错误。

因此，根据代码所实现的逻辑嵌套 try catch 块是有意义的。

我同意您应该避免编写过多的嵌套异常块。

原因是代码变得难以理解。

但是，要解决此问题，您应该更好地设计代码，而不是仅使用一个大的 try catch 。

这种方法使代码难以理解，是很危险的，因为当引发异常时，您将很难找出真正的情况。

相反，您应该将代码分成更合理的单位，例如小方法，小类等等。

为什么Java有嵌套的try语句？

3 个答案: