¿Qué sucede si un método arroja una excepción que no se especificó en la declaración de método con "throws"

Question

Nunca he usado la cláusula "throws", y hoy un compañero me dijo que tenía que especificar en la declaración de método cuál excepciones que el método puede arrojar. Sin embargo, he estado usando excepciones sin problemas sin hacerlo, entonces, ¿por qué es necesario si, de hecho, se necesita?

Answer 1

Java tiene dos tipos diferentes de excepciones: comprobado Excepciones y sin marcar excepciones.

Las excepciones no comprobadas son subclases de RuntimeException y no es necesario agregar una declaración de tiradas. Todas las demás excepciones deben manejarse en el cuerpo del método, ya sea con una instrucción try/catch o con una declaración throws.

Ejemplo de excepciones sin marcar: IllegalArgumentException que se utiliza a veces para notificar que se ha llamado a un método con argumentos ilegales. No se necesitan lanzamientos.

Ejemplo de excepciones marcadas: IOException que pueden arrojar algunos métodos del paquete java.io. Utilice un try/catch o agregue throws IOException a la declaración del método y delegue el manejo de la excepción al llamador del método.

Answer 2

1. Debe declarar las excepciones comprobadas que arroja su método.
2. Si declara 'throws Exception' que prácticamente cubre la mayoría, si no todas las excepciones marcadas
3. Siempre puede lanzar una excepción de tiempo de ejecución no comprobada y no tener que declarar.

Estoy bastante seguro de si intenta lanzar una excepción marcada, y no ha declarado el método como arrojar ese tipo, el código ni siquiera compila (verificando ahora).

editar, haga lo que si intenta algo tan simple como

public static void main(String[] args) { 
    throw new Exception("bad"); 
} 

se obtiene un error de compilación.

Específicamente para su pregunta, si invoca un método que se declara para lanzar Exception (s), debe intentar/atrapar la invocación del método o declarar que su método arroja las excepciones.

Answer 3

Si se declara un método con la palabra clave throws, cualquier otro método que desee llamar a ese método debe estar preparado para detectarlo o declarar que lanzará una excepción.

Por ejemplo, si desea detener la aplicación debe llamar Thread.sleep(milliseconds);

Pero la declaración de este método dice que va a lanzar una Declaración InterruptedException

:

public static void sleep(long millis) throws InterruptedException 

Así Si desea llamarlo, por ejemplo, en su método principal, debe capturarlo:

public static void main(String args[]) { 
    try { 
     Thread.sleep(1000); 
    } catch(InterruptedException ie) { 
     System.out.println("Opps!"); 
    } 
} 

O hacer que el método también declarar que está lanzando una excepción:

public static void main(String args[]) throws InterruptedException { 
    Thread.sleep(1000); 
} 

Answer 4

Puede ocurrir, incluso con comprobado excepciones. Y a veces puede romper el registro.

Supongamos que un método de biblioteca utiliza este truco para permitir una implementación de Runnable que puede lanzar IOException:

class SneakyThrowTask implements Runnable { 

    public void run() { 
     throwSneakily(new IOException()); 
    } 

    private static RuntimeException throwSneakily(Throwable ex) { 
     return unsafeCastAndRethrow(ex); 
    } 

    @SuppressWarnings("unchecked") 
    private static <X extends Throwable>X unsafeCastAndRethrow(Throwable ex) throws X { 
     throw (X) ex; 
    } 

} 

Y que lo llaman así:

public static void main(String[] args) { 
    try { 
     new SneakyThrowTask().run(); 
    } catch (RuntimeException ex) { 
     LOGGER.log(ex); 
    } 
} 

La excepción no se registrarán. Y como es una excepción comprobada, no puede escribir esto:

public static void main(String[] args) { 
    try { 
     new SneakyThrowTask().run(); 
    } catch (RuntimeException ex) { 
     LOGGER.log(ex); 
    } catch (IOException ex) { 
     LOGGER.log(ex); // Error: unreachable code 
    } 
}