¿Cómo crear excepciones personalizadas en Java? [cerrado]

¿Cómo creamos excepciones personalizadas en Java?

Para definir una excepción marcada , cree una subclase (o jerarquía de subclases) de java.lang.Exception. Por ejemplo:

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

Los métodos que potencialmente pueden lanzar o propagar esta excepción deben declararla:

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

... y el código que llama a este método debe manejar o propagar esta excepción (o ambas):

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

Notará en el ejemplo anterior que IOExceptionse captura y se vuelve a lanzar comoFooException . Esta es una técnica común utilizada para encapsular excepciones (generalmente al implementar una API).

A veces habrá situaciones en las que no querrá forzar a cada método a declarar su implementación de excepción en su cláusula throws. En este caso, puede crear una excepción no marcada . Una excepción no marcada es cualquier excepción que se extiende java.lang.RuntimeException(que en sí misma es una subclase de java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Los métodos pueden lanzar o propagar FooRuntimeExceptionexcepciones sin declararlo; p.ej

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

Las excepciones no verificadas se utilizan generalmente para denotar un error del programador, por ejemplo, pasar un argumento no válido a un método o intentar violar los límites de un índice de matriz.

La java.lang.Throwableclase es la raíz de todos los errores y excepciones que se pueden generar dentro de Java. java.lang.Exceptiony java.lang.Errorson ambas subclases de Throwable. Cualquier cosa que las subclases se Throwablepuedan tirar o atrapar. Sin embargo, normalmente es una mala práctica atrapar o lanzar, Errorya que esto se usa para denotar errores internos de la JVM que el programador no puede "manejar" (por ejemplo OutOfMemoryError). Del mismo modo, debe evitar la captura Throwable, lo que podría resultar en la captura de Errors además de Exceptions.

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

Tíralo como:

 throw new MyException ("Something happened")

Captura como:

catch (MyException e)
{
   // something
}

Para una excepción marcada:

public class MyCustomException extends Exception { }

Técnicamente, cualquier cosa que se extienda Throwablepuede ser arrojada, pero las excepciones son generalmente extensiones de la Exceptionclase para que se verifiquen las excepciones (excepto RuntimeException o las clases basadas en ella, que no están marcadas), a diferencia del otro tipo común de lanzamiento, Errors que generalmente no son algo diseñado para ser manejado con gracia más allá de lo interno de JVM.

También puede hacer que las excepciones no sean públicas, pero solo puede usarlas en el paquete que las define, en lugar de en todos los paquetes.

En cuanto a lanzar / atrapar excepciones personalizadas, funciona igual que las incorporadas: lanzar a través de

throw new MyCustomException()

y atrapar a través de

catch (MyCustomException e) { }