Jak tworzyć niestandardowe wyjątki w Javie? [Zamknięte]

Jak tworzymy niestandardowe wyjątki w Javie?

Aby zdefiniować zaznaczony wyjątek, należy utworzyć podklasę (lub hierarchię podklas) java.lang.Exception. Na przykład:

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

Metody, które mogą potencjalnie zgłosić lub propagować ten wyjątek, muszą go zadeklarować:

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

... a kod wywołujący tę metodę musi obsługiwać lub propagować ten wyjątek (lub oba):

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

W powyższym przykładzie zauważysz, że IOExceptionjest przechwytywany i ponownie odrzucany jako FooException. Jest to powszechna technika używana do hermetyzacji wyjątków (zwykle podczas implementowania interfejsu API).

Czasami zdarzają się sytuacje, w których nie chcesz wymuszać na każdej metodzie deklarowania implementacji wyjątku w klauzuli throws. W takim przypadku możesz utworzyć niezaznaczony wyjątek. Niezaznaczony wyjątek to każdy wyjątek, który rozszerza java.lang.RuntimeException(który sam jest podklasą java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Metody mogą zgłaszać lub propagować FooRuntimeExceptionwyjątek bez jego deklarowania; na przykład

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

Niezaznaczone wyjątki są zwykle używane do oznaczenia błędu programisty, na przykład przekazywania nieprawidłowego argumentu do metody lub próby naruszenia granic indeksu tablicy.

java.lang.ThrowableKlasa jest korzeniem wszystkich błędów i wyjątków, które mogą zostać wyrzucone w ciągu Java. java.lang.Exceptioni java.lang.Errorobie są podklasami Throwable. Wszystko, co podklasy Throwablemoże zostać rzucone lub złapane. Jednak przechwytywanie lub wyrzucanie jest zazwyczaj złą praktyką, Errorponieważ jest to używane do oznaczania błędów wewnętrznych JVM, które zwykle nie mogą być „obsługiwane” przez programistę (np OutOfMemoryError.). Powinieneś także unikać łapania Throwable, które mogłoby spowodować, Errorże oprócz Exceptions.

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

Rzuć to jako:

 throw new MyException ("Something happened")

Złap jako:

catch (MyException e)
{
   // something
}

W przypadku zaznaczonego wyjątku:

public class MyCustomException extends Exception { }

Technicznie rzecz biorąc, wszystko, co rozszerza, Throwablemoże być wyrzucone, ale wyjątki są zwykle rozszerzeniami Exceptionklasy, więc są sprawdzanymi wyjątkami (z wyjątkiem RuntimeException lub klas na nim opartych, które nie są sprawdzane), w przeciwieństwie do innych powszechnych typów elementów do rzucania, Errorktóre zazwyczaj nie są zaprojektowane do wygodnej obsługi poza wewnętrznymi mechanizmami JVM.

Możesz także uczynić wyjątki niepublicznymi, ale wtedy możesz ich używać tylko w pakiecie, który je definiuje, w przeciwieństwie do wszystkich pakietów.

Jeśli chodzi o wyrzucanie / łapanie niestandardowych wyjątków, działa to tak samo, jak te wbudowane - rzut przez

throw new MyCustomException()

i złap przez

catch (MyCustomException e) { }