Wie erstelle ich benutzerdefinierte Ausnahmen in Java? [geschlossen]

Wie erstellen wir benutzerdefinierte Ausnahmen in Java?

Um eine aktivierte Ausnahme zu definieren , erstellen Sie eine Unterklasse (oder eine Hierarchie von Unterklassen) von java.lang.Exception. Beispielsweise:

public class FooException extends Exception {
  public FooException() { super(); }
  public FooException(String message) { super(message); }
  public FooException(String message, Throwable cause) { super(message, cause); }
  public FooException(Throwable cause) { super(cause); }
}

Methoden, die diese Ausnahme möglicherweise auslösen oder verbreiten können, müssen sie deklarieren:

public void calculate(int i) throws FooException, IOException;

... und Code, der diese Methode aufruft, muss diese Ausnahme (oder beides) entweder behandeln oder weitergeben:

try {
  int i = 5;
  myObject.calculate(5);
} catch(FooException ex) {
  // Print error and terminate application.
  ex.printStackTrace();
  System.exit(1);
} catch(IOException ex) {
  // Rethrow as FooException.
  throw new FooException(ex);
}

Sie werden im obigen Beispiel feststellen, dass IOExceptionals gefangen und erneut geworfen wird FooException. Dies ist eine gängige Technik zum Einkapseln von Ausnahmen (normalerweise beim Implementieren einer API).

Manchmal gibt es Situationen, in denen Sie nicht jede Methode zwingen möchten, Ihre Ausnahmeimplementierung in ihrer throw-Klausel zu deklarieren. In diesem Fall können Sie eine ungeprüfte Ausnahme erstellen . Eine nicht aktivierte Ausnahme ist eine Ausnahme, die erweitert wird java.lang.RuntimeException(die selbst eine Unterklasse von ist java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Methoden können FooRuntimeExceptionAusnahmen auslösen oder verbreiten, ohne sie zu deklarieren. z.B

public void calculate(int i) {
  if (i < 0) {
    throw new FooRuntimeException("i < 0: " + i);
  }
}

Nicht aktivierte Ausnahmen werden normalerweise verwendet, um einen Programmiererfehler zu kennzeichnen, z. B. das Übergeben eines ungültigen Arguments an eine Methode oder den Versuch, die Grenzen eines Array-Index zu überschreiten.

Die java.lang.ThrowableKlasse ist die Wurzel aller Fehler und Ausnahmen, die in Java ausgelöst werden können. java.lang.Exceptionund java.lang.Errorsind beide Unterklassen von Throwable. Alles, was Unterklassen sind, Throwablekann geworfen oder gefangen werden. Es ist jedoch in der Regel eine schlechte Praxis, zu fangen oder zu werfen, Errorda dies verwendet wird, um Fehler innerhalb der JVM zu kennzeichnen, die normalerweise vom Programmierer nicht "behandelt" werden können (z OutOfMemoryError. B. ). Ebenso sollten Sie das Fangen vermeiden Throwable, da dies dazu führen kann, dass Sie Errorzusätzlich zu Exceptions auch s fangen .

public class MyException extends Exception {
        // special exception code goes here
}

Wirf es als:

 throw new MyException ("Something happened")

Fang als:

catch (MyException e)
{
   // something
}

Für eine aktivierte Ausnahme:

public class MyCustomException extends Exception { }

Technisch gesehen kann alles, was erweitert wird Throwable, ausgelöst werden, aber Ausnahmen sind im Allgemeinen Erweiterungen der ExceptionKlasse, sodass sie geprüfte Ausnahmen sind (mit Ausnahme von RuntimeException oder darauf basierenden Klassen, die nicht geprüft werden), im Gegensatz zu dem anderen gängigen Typ von throwable. Errors, die normalerweise nicht für einen ordnungsgemäßen Umgang mit JVM-Interna ausgelegt sind.

Sie können Ausnahmen auch nicht öffentlich machen, aber dann können Sie sie nur in dem Paket verwenden, das sie definiert, und nicht zwischen Paketen.

Was das Werfen / Abfangen von benutzerdefinierten Ausnahmen betrifft, funktioniert es genauso wie die integrierten - werfen über

throw new MyCustomException()

und fangen über

catch (MyCustomException e) { }