Diferencia entre try-finally y try-catch

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 más la segunda versión porque me da acceso al 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?

Estas son dos cosas diferentes:

  • El bloque catch solo se ejecuta si se lanza una excepción en el bloque try.
  • El bloque finally se ejecuta siempre después del bloque try (-catch), si se lanza una excepción o no.

En tu ejemplo no has mostrado el tercer constructo 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 el bloque finally se ejecuta incluso si no hay una excepción.

Por supuesto, puede declarar una variable que mantiene la excepción fuera de su bloque y asignar un valor dentro del bloque catch. Luego puedes acceder a esta variable dentro de tu bloque final.

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

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

Finalmente y los bloques de captura son bastante diferentes:

  • Dentro del bloque catch puede responder a la excepción lanzada. Este bloque se ejecuta solo si hay una excepción no controlada y el tipo coincide con uno o es una subclase de la especificada en el parámetro del bloque catch.
  • Finalmente, siempre se ejecutará después de los bloques try and catch, ya sea que haya una excepción o no.

Asi que

 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 define un bloque try tiene que definir

  1. uno finalmente bloquea, o
  2. uno o más bloques de captura, o
  3. uno o más bloques de captura y uno finalmente bloque

Entonces 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 } 
 try { statements; } catch (exceptionType1 e1) { // one or multiple statements; } catch (exceptionType2 e2) { statements; } ... } finally { // one or none statements; } 
  1. Todas las declaraciones de prueba deben incluir una cláusula catch o una cláusula finally
  2. Puede tener varias cláusulas catch, pero solo una cláusula finalmente
  3. Durante cualquier ejecución, si se produce algún error, el control se transfiere al bloque de captura apropiado y ejecuta las instrucciones y se ejecuta el bloque de última instancia.

No importa lo que se ejecute El bloque Finally, por lo tanto, en general, se usa el bloque Finally, cuando tiene sesiones, las conexiones de la base de datos o los archivos o sockets están abiertos, luego se colocará el código para cerrar esas conexiones. Esto es solo para asegurarse de que en una aplicación no haya memory leaks o que no se produzcan otros problemas.

Finalmente y los bloques de captura son bastante diferentes:

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

try se usa para ejecutar un método que puede lanzar una excepción

catch se usa para “catch” detener esa excepción

Finalmente se utiliza para cualquier limpieza necesaria de la excepción que se captura 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 } 

En el bloque Mi re-búsqueda Finalmente, siempre se ejecuta y se utiliza principalmente para que cualquier conexión abierta se cierre y se destruya algo que se esté ejecutando innecesariamente.

Finalmente el bloque siempre se ejecuta. El bloque de captura se ejecuta solo cuando se detecta una excepción que coincide con el parámetro de bloques.

Incluso en el primer formulario puede iniciar sesión en el método de llamada. Por lo tanto, no hay una gran ventaja a menos que desee realizar un manejo especial allí mismo.

Generalmente, cuando usamos recursos como flujos, conexiones, etc., tenemos que cerrarlos explícitamente utilizando el bloque finally. En el progtwig que se presenta a continuación, estamos leyendo datos de un archivo usando FileReader y lo estamos cerrando usando el bloque finalmente.

 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 buscaron algo como esto.

Información de esta página tutpoint