Cuándo utilizar los tiros en una declaración de método Java?

Question

Así que pensé que tenía una buena comprensión básica de control de excepciones en Java, pero poco leí un código que me dio algo de confusión y dudas. Mi duda principal que quiero dirección aquí es cuando se debe utilizar un observador lanza en una declaración de método Java como la siguiente:

    public void method() throws SomeException
    {
         // method body here
    }

A partir de la lectura de algunos mensajes similares deduzco que lanza se utiliza como una especie de declaración de que SomeException podría ser lanzado durante la ejecución del método.

Mi confusión proviene de un código que se veía así:

     public void method() throws IOException
     {
          try
          {
               BufferedReader br = new BufferedReader(new FileReader("file.txt"));
          }
          catch(IOException e)
          {
               System.out.println(e.getMessage());
          }
     }

¿Hay alguna razón por la que se desea utilizar un lanza en este ejemplo? Parece que si se acaba de hacer básica de control de excepciones de algo así como una IOException que simplemente tendría el bloque try / catch y eso es todo.

Answer 1

Si tienes que coger un tipo de excepción, no es necesario para tirarlo, a menos que se va a volver a lanzar la misma. En el ejemplo que publique, el desarrollador debería haber hecho una u otra, no ambas.

Por lo general, si no se va a hacer cualquier cosa con la excepción, no debe cogerlo.

Lo más peligroso que puede hacer es coger una excepción y no hacer nada con él.

Una buena discusión de cuándo es apropiado para lanzar excepciones es aquí

Cuando a lanzar una excepción?

Answer 2

Sólo es necesario incluir una cláusula throws en un método si el método lanza una excepción comprobada. Si el método lanza una excepción de tiempo de ejecución, entonces no hay necesidad de hacerlo.

Consulte aquí por algunos antecedentes sobre comprobado vs excepciones sin marcar: http: / /download.oracle.com/javase/tutorial/essential/exceptions/runtime.html

Si el método detecta la excepción y se ocupa de forma interna (como en el segundo ejemplo), entonces no hay necesidad de incluir una cláusula throws.

Answer 3

El código que ha mirado no es lo ideal. Usted deberá:

1. detectar la excepción y manejarlo; en cuyo caso el throws es innecesaria.

2. Eliminar el try/catch; en ese caso la excepción será manejado por una llamando al método.

3. detectar la excepción, posiblemente realizar alguna acción y luego volver a lanzar la excepción (no sólo el mensaje)

Answer 4

Usted es correcta, en ese ejemplo el throws es superfluo. Es posible que se dejó allí desde alguna aplicación anterior -. Quizás la excepción fue lanzada originalmente en lugar de atrapados en el bloque catch

Answer 5

En el ejemplo que dio, el método nunca lanzar una IOException, por lo tanto, la declaración está mal (pero válida). Mi conjetura es que el método original arrojó el IOException, pero se actualiza para manejar la excepción dentro de la declaración, pero no se ha modificado.

Answer 6

El código que envió está mal, debe lanzar una excepción si se captura una excepción específica con el fin de manipulador de IOException pero lanzar excepciones no atrapadas.

Algo así como:

public void method() throws Exception{
   try{
           BufferedReader br = new BufferedReader(new FileReader("file.txt"));
   }catch(IOException e){
           System.out.println(e.getMessage());
   }
}

o

public void method(){
   try{
           BufferedReader br = new BufferedReader(new FileReader("file.txt"));
   }catch(IOException e){
           System.out.println("Catching IOException");
           System.out.println(e.getMessage());
   }catch(Exception e){
           System.out.println("Catching any other Exceptions like NullPontException, FileNotFoundExceptioon, etc.");
           System.out.println(e.getMessage());
   }

}

Answer 7

Esto no es una respuesta, pero un comentario, pero yo no podía escribir un comentario con un código con formato, por lo que aquí es el comentario.

Digamos que existe

public static void main(String[] args) {
  try {
    // do nothing or throw a RuntimeException
    throw new RuntimeException("test");
  } catch (Exception e) {
    System.out.println(e.getMessage());
    throw e;
  }
}

La salida es

test
Exception in thread "main" java.lang.RuntimeException: test
    at MyClass.main(MyClass.java:10)

Ese método no declara ninguna "lanza" Excepciones, pero los tira! El truco es que las excepciones producidas son RuntimeExceptions (no marcado) que no son necesarios para ser declarado en el método. Es un poco engañoso para el lector del método, ya que todo lo que ve es un "tiro e;" declaración, pero ninguna declaración de la lanza excepción

Ahora, si tenemos

public static void main(String[] args) throws Exception {
  try {
    throw new Exception("test");
  } catch (Exception e) {
    System.out.println(e.getMessage());
    throw e;
  }
}

Debe declarar la "tiros" excepciones en el método de lo contrario, consiguen un error de compilación.