Ausnahmebehandlungspraktiken von mehreren Ausnahmen werfenden Funktionen

Question

Wenn ich mehrere Funktionen in einer Funktion habe, die Ausnahmen auslösen, was ist der beste Weg, sie zu behandeln, wenn sie voneinander abhängen?

Mit voneinander abhängig meine ich, dass, wenn etwas eine Ausnahme auslöst, der Code nach der Funktion, die die Ausnahme ausgelöst hat, übersprungen werden sollte.

dachte ich drei Auswege, dies zu tun:

Verschachtelung Ausnahme

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

Return on Ausnahme

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; 
    } 

    ... 
} 

Ausnahmen Methode Signatur hinzufügen

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

Ich benutze manchmal alle zusammen und das ist ein Durcheinander. Gibt es gute Praktiken, um mit solchen Situationen umzugehen?

Answer 1

Die Art und Weise hängt davon ab, zu verwenden, ob die Ausnahmen vom Auftraggeber der someFunction() Methode oder auch abgefangen und behandelt, sobald sie geschehen behandelt werden sollen, das heißt, innerhalb der someFunction() Methode.

In der Ausnahme Schachtel ist die Schachtelung nicht erforderlich.
Sie können eine einzelne try-Anweisung verwenden und die zwei Aufrufe platzieren, die die Ausnahmen generieren können.
Wenn eine Ausnahme in einer der zwei aufgerufenen Methoden auftritt, beenden Sie in einer der catch-Anweisungen und so wird die zweite Methode nur ausgeführt, wenn der erste die gefangene Ausnahme nicht ausgelöst hat. Es produziert genau das gleiche Ergebnis als Ihr Code, aber mit einer einzigen try und ohne Verschachtelung, die weniger lesbar ist.

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

diese Weise zu tun, ist geeignet, wenn Sie einige andere Anweisungen nach den catch Aussagen haben, und Sie wollen, dass sie selbst dann ausgeführt werden, wenn einer der erwarteten Ausnahmen gefangen wurde.

Die Rückgabe bei Ausnahmefall manifestiert ein nahe genug Problem.
Es kann mit einem einzigen try Refactoring:

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

Auf diese Weise geeignet zu tun ist, wenn Sie einige andere Anweisungen nach den catch Aussagen haben und Sie nicht wollen, sie, wenn einer der erwarteten ausgeführt werden Ausnahmen wurden gefangen.

Dennoch für diese beiden Fälle, wenn die Ausnahmebehandlung die gleiche für die beiden Ausnahmen (Func1Exception und Func2xception) ist, könnten Sie gruppieren sie in einer einzigen Anweisung Haken:

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

Endlich der Hinzufügen von Ausnahmen zum Methodensignaturfall macht nur Sinn, wenn die Ausnahmen vom Client der Methode behandelt werden sollen.

Answer 2

Sie können mehrere Ausnahmen in einer catch-Klausel fangen, ausgehend von Java 7, glaube ich.

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