salida - todas las excepciones en java

¿Cuándo usar throws en una declaración de método Java?

Question

Así que pensé que tenía una buena comprensión básica del manejo de excepciones en Java, pero hace poco estuve leyendo un código que me dio cierta confusión y dudas. Mi principal duda que deseo abordar aquí es cuándo debería una persona utilizar arroja una declaración de método Java como la siguiente:

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

De la lectura de publicaciones similares, deduzco que throws se utiliza como una especie de declaración de que SomeException podría lanzarse durante la ejecución del método.

Mi confusión proviene de algún 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 te gustaría usar un lanzamiento en este ejemplo? Parece que si solo está haciendo un manejo básico de excepciones de algo así como una IOException, simplemente necesitaría el bloque try / catch y eso es todo.

Answer 1

El código que miraste no es ideal. Usted debe:

1. Captura la excepción y manejarlo; en cuyo caso los throws son innecesarios.

2. Eliminar el try/catch ; en cuyo caso, la Excepción será manejada por un método de llamada.

3. Capture la excepción, posiblemente realice alguna acción y luego vuelva a lanzar la excepción (no solo el mensaje)

Answer 2

El código que publicaste está equivocado, debería arrojar una excepción si está atrapando una excepción específica para gestionar IOException pero lanzar excepciones no atrapadas.

Algo 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 3

En el ejemplo que proporcionó, el método nunca lanzará una IOException, por lo tanto, la declaración es incorrecta (pero válida). Supongo que el método original arrojó IOException, pero luego se actualizó para manejar la excepción dentro pero la declaración no se modificó.

Answer 4

Estás en lo cierto, en ese ejemplo los throws son superfluos. Es posible que se haya dejado allí debido a alguna implementación previa, tal vez la excepción se lanzó originalmente en lugar de quedar atrapada en el bloque catch.

Answer 5

Esta no es una respuesta, sino un comentario, pero no pude escribir un comentario con un código formateado, así que aquí está el comentario.

Digamos que hay

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

El resultado es

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

¡Ese método no declara excepciones de "lanzamientos", sino que las lanza! El truco es que las excepciones lanzadas son RuntimeExceptions (sin marcar) que no son necesarias para ser declaradas en el método. Es un poco engañoso para el lector del método, ya que todo lo que ella ve es un "tiro e"; declaración pero ninguna declaración de la excepción de lanzamientos

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

DEBEMOS declarar las excepciones "throws" en el método, de lo contrario obtenemos un error de compilación.

Answer 6

Si está capturando un tipo de excepción, no necesita tirarlo, a menos que vaya a volver a lanzarlo. En el ejemplo que publica, el desarrollador debería haber hecho uno u otro, no ambos.

Normalmente, si no va a hacer nada con la excepción, no debería atraparlo.

Lo más peligroso que puede hacer es atrapar una excepción y no hacer nada con ella.

Una buena discusión sobre cuándo es apropiado lanzar excepciones está aquí

¿Cuándo lanzar una excepción?

Answer 7

Solo necesita incluir una cláusula throws en un método si el método arroja una excepción marcada. Si el método arroja una excepción de tiempo de ejecución, entonces no hay necesidad de hacerlo.

Consulte aquí para obtener información general sobre las excepciones controladas frente a las no verificadas: http://download.oracle.com/javase/tutorial/essential/exceptions/runtime.html

Si el método detecta la excepción y la trata internamente (como en el segundo ejemplo), entonces no es necesario incluir una cláusula throws.