多個異常拋出函數的異常處理實踐

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()方法內。

在異常嵌套的情況下 ，不需要嵌套。
您可以使用單個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語句之后有一些其他指令，並且如果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) { 
  ...
}