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

如果一个函数中有多个函数抛出异常，如果它们相互依赖，那么处理它们的最佳方法是什么

关于相互依赖，我的意思是，如果有东西抛出异常，则应该跳过抛出异常的函数后面的代码

我想出了三种方法：

异常嵌套

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();
    ...
}

---

我有时把它们都用在一起，真是一团糟。关于如何处理这种情况，有什么好的实践吗？

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

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

---

使用方法取决于异常是由

someFunction（）

方法的客户端处理，还是在异常发生时立即捕获并处理，即在

someFunction（）

方法内部。

在异常嵌套情况下，不需要嵌套。
您可以使用一个

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!");
    }
}

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