¿Cómo crear excepciones personalizadas en Java?

Question

¿Cómo creamos excepciones personalizadas en Java?

Answer 1

Para definir una comprobado excepción se crea una subclase (o jerarquía de las 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); } 
} 

métodos que potencialmente pueden lanzar o propagar esta excepción debe declarar que:

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

... y el código debe llamar a este método, ya sea manejar o propagar esta excepción (o ambos):

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

se dará cuenta en el ejemplo anterior que estaba en IOException y relanza como FooException. Esta es una técnica común utilizada para encapsular excepciones (generalmente cuando se implementa una API).

A veces habrá situaciones en las que no desee obligar a todos los métodos a declarar su implementación de excepción en su cláusula throws. En este caso, puede crear una excepción sin marcar. Una excepción sin control es cualquier excepción que se extiende java.lang.RuntimeException (que en sí es una subclase de java.lang.Exception):

public class FooRuntimeException extends RuntimeException { 
    ... 
} 

métodos pueden lanzar o propagar FooRuntimeException excepción sin declarar; p.ej.

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

excepciones no comprobadas se utilizan normalmente para indicar un error del programador, por ejemplo pasando un argumento no válido a un método o el intento de violación de un límites índice de matriz.

La clase java.lang.Throwable es la raíz de todos los errores y excepciones que se pueden lanzar dentro de Java. java.lang.Exception y java.lang.Error son ambas subclases de Throwable. Cualquier cosa que las subclases Throwable puedan arrojarse o atraparse. Sin embargo, normalmente es una mala práctica capturar o lanzar Error ya que esto se utiliza para denotar errores internos a la JVM que generalmente no pueden ser "manejados" por el programador (por ejemplo, OutOfMemoryError). Del mismo modo, debe evitar atrapar Throwable, lo que podría ocasionar que atrape Error s además de Exception s.

Answer 2

Para una excepción comprobada:

public class MyCustomException extends Exception { } 

Técnicamente, cualquier cosa que se extiende Throwable puede ser una lanzada, pero las excepciones son por lo general las extensiones de la clase Exception para que estén controladas (excepto excepciones RuntimeException o clases basadas en esto, que no están marcados), a diferencia del otro tipo común de objetos arrojadizos, Error, que generalmente no son algo diseñado para ser manejado elegantemente más allá de las partes internas de JVM.

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

En lo que a tirar/captura de excepciones personalizadas, funciona igual que los incorporados - tirar a través de

throw new MyCustomException() 

y atrapar a través

catch (MyCustomException e) { } 

Answer 3

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

Throw como:

throw new MyException ("Something happened") 

Ver como:

catch (MyException e) 
{ 
    // something 
}