Question

如果我在函数中有多个函数抛出异常，那么如果它们彼此依赖，那么处理它们的最佳方法是什么？

依赖于彼此，我的意思是如果某些事情抛出异常，则应该跳过抛出异常的函数之后的代码。

我想出了三种方法：

例外嵌套

public void parent() {
    someFunction();
}

public void someFunction() {
    try {
        function1();
        try {
            function2();
            ...
        } catch (Func2xception e) {
            System.out.println("Function 2 failed!");
        }
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
    }
}

异常返回

public void parent() {
    someFunction();
}

public void someFunction() {
    try {
        function1();
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
        return;
    }

    try {
        function2();
    } catch (Func2xception e) {
        System.out.println("Function 2 failed!");
        return;
    }

    ...
}

为方法签名添加例外

public void parent() {
    try {
        someFunction();
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
    } catch (Func2Exception e) {
        System.out.println("Function 2 failed!");
    } ...
}

public void someFunction() throws Func1Exception, Func2Exception {
    function1();
    function2();
    ...
}

我有时会把所有这些都用在一起，这太乱了。如何处理这样的情况有什么好的做法吗？

Answer 1

使用方法取决于异常是由someFunction()方法的客户端处理，还是在它们发生时立即捕获和处理，即在someFunction()方法内。 BR />

在例外嵌套案例中，不需要嵌套您可以使用单个try语句并将可能在其中生成例外的两个调用放在其中如果在两个调用的方法之一中发生异常，则在其中一个catch语句中完成，因此仅当第一个方法未抛出捕获的异常时才执行第二个方法。它产生的结果与您的代码完全相同，但只有一个try，没有嵌套，可读性较差。

public void someFunction() {
    try {
        function1();    
        function2();
            ...      
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
    }
    catch (Func2xception e) {
        System.out.println("Function 2 failed!");
    }    
}

如果您在catch语句后面有其他指令，并且希望执行其中一个预期的例外，那么这种做法是合适的。

异常情况下的返回表现出足够接近的问题。
它可以用单个try重构：

    public void someFunction() {
        try {
            function1();    
            function2();
                ...      
        } catch (Func1Exception e) {
            System.out.println("Function 1 failed!");
            return;
        }
        catch (Func2xception e) {
            System.out.println("Function 2 failed!");
            return;
        }    
    }
    ...
}

如果您在catch语句之后有其他指令，并且如果捕获到其中一个预期异常，则不希望执行这些操作，这种做法很合适。

尽管如此，对于这两种情况，如果两个异常（Func1Exception和Func2xception）的异常处理相同，则可以将它们分组到一个catch语句中：

public void someFunction() {
    try {
        function1();    
        function2();
            ...      
    } 
    catch (Func1Exception | Func2xception e) {
        System.out.println("Function 1 or 2 failed!");
    }
}

最后，只有当方法的客户端处理异常时，添加方法签名案例的例外才有意义。

Answer 2

你可以在一个catch子句中捕获多个异常，从我相信的Java 7开始。

try { 
  ...
} catch(IOException | IllegalArgumentException | SomeOtherException e) { 
  ...
}

多个异常抛出函数的异常处理实践

2 个答案: