java - try - Qué sucede si un método lanza una excepción que no se especificó en la declaración del método con "tiros"

throw exception php

Question

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

Answer 1

1. Debe declarar las excepciones marcadas que arroja su método.
2. Si declara ''arroja Excepción'' que cubre casi la mayoría, si no todas las excepciones verificadas
3. Siempre puede lanzar una excepción de tiempo de ejecución sin marcar y no tener que declarar.

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

EDITAR, así que si intentas algo 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 Excepciones, debe probar / capturar la invocación del método o declarar que su método arroja las excepciones.

Answer 2

Java tiene dos tipos diferentes de excepciones: Excepciones marcadas y Excepciones no marcadas .

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

Ejemplo para excepciones no verificadas: IllegalArgumentException que se usa a veces para notificar que se ha llamado a un método con argumentos ilegales. No se necesitan tiros.

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

Answer 3

La palabra clave de throws se utiliza para lanzar una excepción a otro método.

Facilita la excepción de manejo al usuario. Porque entonces todas las excepciones se pueden manejar en un método que se utiliza para ejecutar.

Principalmente es principalmente un método, de modo que el usuario no necesita explorar dentro del método.

También arroja fuerza de palabra clave al compilador para manejar la excepción que podría estar ocurriendo.

Si era un desarrollador de API, cuando escribe un código, podría ver que podría producirse una excepción, por lo que utiliza la palabra clave throws para controlarla cuando se ejecuta el método.

Answer 4

Puede suceder, incluso con excepciones comprobadas . 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 Runnable 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 lo llamas así:

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

La excepción nunca será registrada. Y porque es una excepción marcada, no puedes 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
    }
}

Answer 5

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

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

Pero la declaración de este método dice que lanzará una InterruptedException

Declaración:

public static void sleep(long millis) throws InterruptedException

Entonces, si deseas llamarlo por ejemplo en tu método principal, debes capturarlo:

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

O haga que el método también declare que está lanzando una excepción:

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

Answer 6

Java lanza palabra clave,

• La palabra clave de Java se utiliza para declarar una excepción.
• throws son seguidos por la clase.
• Excepción comprobada se puede propagar con throws .
• Proporciona información a la persona que llama del método sobre la excepción.

throws ejemplo,

void m()throws ArithmeticException{  
    //method code  
}