Diferencia entre try-finally y try-catch

Question

¿Cuál es la diferencia entre

try {
    fooBar();
} finally {
    barFoo();
}

y

try {
  fooBar();
} catch(Throwable throwable) {
    barFoo(throwable); // Does something with throwable, logs it, or handles it.
}

Me gusta la segunda versión mejor, ya que me da acceso a la Throwable. ¿Hay alguna diferencia lógica o una convención preferida entre las dos variaciones?

Además, hay una manera de acceder a la excepción de la cláusula finally?

Answer 1

Estos son dos cosas diferentes:

• El bloque catch sólo se ejecuta si se produce una excepción en el bloque try.
• El bloque finally se ejecuta siempre después de que el bloque try (-catch), si se produce una excepción o no.

En el ejemplo usted no ha mostrado la tercera construcción posible:

try {
    // try to execute this statements...
}
catch( SpecificException e ) {
    // if a specific exception was thrown, handle it here
}
// ... more catches for specific exceptions can come here
catch( Exception e ) {
    // if a more general exception was thrown, handle it here
}
finally {
    // here you can clean things up afterwards
}

Y, como @codeca dice en su comentario, no hay manera de acceder a la excepción dentro del bloque finally, porque se ejecuta el bloque finally incluso si no hay excepción.

Por supuesto podría declarar una variable que contiene el exterior a excepción de su bloque y asignar un valor dentro del bloque catch. Después se puede acceder a esta variable dentro de su bloque finally.

Throwable throwable = null;
try {
    // do some stuff
}
catch( Throwable e ) {
    throwable = e;
}
finally {
    if( throwable != null ) {
        // handle it
    }
}

Answer 2

Estas no son las variaciones, son cosas fundamentalmente diferentes. se ejecuta finally siempre , solamente catch cuando se produce una excepción.

Answer 3

Por último y bloques de captura son bastante diferentes:

• En el bloque catch se puede responder a la excepción lanzada. Este bloque se ejecuta sólo si hay una excepción no controlada y el tipo coincide con el uno o es subclase de la especificada en el parámetro del bloque catch.
• Finalmente se ejecuta siempre después de bloques try y catch si existe una excepción eleva o no.

---

Entonces

try {
  //some code
}
catch (ExceptionA) {
  // Only gets executed if ExceptionA 
  // was thrown in try block
}
catch (ExceptionB) {
  // Only executed if ExceptionB was thrown in try 
  // and not handled by first catch block
}

difiere de

try {
  //some code
}
finally {
  // Gets executed whether or not 
  // an exception was thrown in try block
}

significativamente.

Si se define un bloque try tiene que definir

1. uno finalmente bloque, o
2. uno o más bloques de captura, o
3. una o más capturas bloqueos y un bloque finally

Así que el siguiente código sería válido también:

try {
  //some code
}
catch (ExceptionA) {
  // Only gets executed if 
  // ExceptionA was thrown in try block
}
catch (ExceptionB) {
  // Only executed if ExceptionB was thrown in 
  // try and not handled by first catch block
}
//even more catch blocks
finally {
  // Gets executed whether or not an 
  // exception was thrown in try block
}

Answer 4

try {
    statements;
} catch (exceptionType1 e1) {      // one or multiple
    statements;                 
} catch (exceptionType2 e2) {
    statements;
}    
...
} finally {                                 // one or none
    statements;
}

1. Todas las sentencias try debe incluir ya sea una cláusula catch o una cláusula finally
2. Puede tener un múltiples cláusulas catch pero sólo una cláusula finally
3. Durante cualquier ejecución, si se produce algún error, entonces el control se transfiere al bloque Catch apropiado y ejecuta las instrucciones y, finalmente, se ejecuta el bloque.

No importa lo que siempre se ejecuta el bloque Finalmente, lo que en general, se utiliza último bloque, cuando se tiene sesiones, las conexiones de base de datos o archivos o sockets están abiertos, a continuación, se colocará el código para el cierre de esas conexiones. Esto es sólo para asegurarse de que una solicitud no deben producirse pérdidas de memoria o cualquier otra cuestión.

Answer 5

Por último y bloques de captura son bastante diferentes:

Dentro del bloque catch que puede responder a la excepción lanzada. Este bloque se ejecuta sólo si hay una excepción no controlada y el tipo coincide con el uno o es subclase de la especificada en el parámetro del bloque catch. Finalmente se ejecuta siempre después de bloques try y catch si existe una excepción eleva o no.

Answer 6

intento se utiliza para ejecutar un método que puede lanzar una excepción

catch se utiliza para "capturar" parada esa excepción

Por último se utiliza para cualquier la limpieza necesaria de dicha excepción ser atrapados o no

try{
    myObject.riskyMethod(); // run a method that may throw an exception
}
catch(Exception ex){
    myLogger.log(ex.Message); // "catch" stop that exception
}
finally{
    myObject = null; // clean up needed from that exception being caught
}

Answer 7

En Mi investigación último bloque se ejecuta siempre y es principalmente "utilizado para las conexiones abiertas a cerrar" y destruir algo que se está ejecutando de forma innecesaria.

Answer 8

Por último bloque se ejecuta siempre. se ejecuta bloque Catch sólo cuando una excepción que corresponden con los bloques de parámetros es apresado.

Answer 9

Incluso en la primera forma pudo iniciar sesión en el método de llamada. Así que no hay gran ventaja a menos que desee hacer algún tratamiento especial allí mismo.

Answer 10

En general, cuando se utiliza cualquier recurso como arroyos, conexiones, etc .. tenemos que cerrar explícitamente el uso de este bloque. En el programa que figura a continuación estamos leyendo datos de un archivo usando FileReader y estamos cerrando usando este bloque.

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]){
      FileReader fr=null;       
      try{
         File file=new File("file.txt");
         fr = new FileReader(file);  char [] a = new char[50];
         fr.read(a); // reads the content to the array
         for(char c : a)
         System.out.print(c); //prints the characters one by one
      }catch(IOException e){
          e.printStackTrace();
       }
       finally{ 
          try{
              fr.close();
          }catch(IOException ex){       
               ex.printStackTrace();
           }
       }
    }

}

Tal vez otros tipos como yo buscaba algo como esto.

La información de esta página tutpoint

Answer 11

bloque Try llevará a cabo las declaraciones que van a excepción aumento. El bloque catch llevará a cabo la referencia lanzados desde el bloque try y mensajes necesarios se generan a partir bloque catch. Por último bloque también se utiliza para cerrar los recursos usados ??como cierre io, cierre el archivo, cierre dB .. En Java -9 reforzada con try-recursos se acercó donde se declaran los recursos fuera de la try..in enchanced tratar con los recursos del bloque catch es obligatorio