diferencia entre la captura try-try-finally y

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 alguna 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 del bloque try (-catch), si se lanza una excepción o no.

En su ejemplo que no han 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 el bloque finally se ejecuta incluso si no hay excepción.

Por supuesto, puede declarar una variable que contiene 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 finally.

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

Answer 2

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

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

finalmente se utiliza para cualquier Limpiemos necesaria de dicha excepción se capturan 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 3

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

Answer 4

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

Answer 5

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

1. Todo tratar las afirmaciones deben 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 toda la ejecución, si se produce algún error, a continuación, el control se transfiere al bloque de captura 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, es finalmente utilizado 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 solo para asegurarse de que en una aplicación no haya pérdidas de memoria o Cualquier otro problema no debería ocurrir.

Answer 6

bloques Finalmente y de captura son bastante diferentes:

• Dentro del bloque catch se puede responder a la excepción lanzada. Este bloque se ejecuta solo si hay una excepción no controlada y el tipo coincide con la una o es la subclase de la especificada en el parámetro del bloque catch.
• Finalmente se ejecutará siempre después de probar y atrapar bloques si hay una excepción planteada o no.

---

Así

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. un bloque finally, o
2. uno o más bloques de captura, o
3. uno o más bloques de captura 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 7

Incluso en el primer formulario, puede iniciar sesión en el método de llamada. Entonces no hay una gran ventaja a menos que quieras hacer un manejo especial allí mismo.

Answer 8

En My reasearch Finalmente, el bloque siempre se ejecuta y se utiliza principalmente para cerrar las conexiones abiertas y para destruir algo que se ejecuta innecesariamente.

Answer 9

bloques Finalmente y de captura son bastante diferentes:

Dentro del bloque catch se puede responder a la excepción lanzada. Este bloque se ejecuta solo si hay una excepción no controlada y el tipo coincide con la o con la subclase de la especificada en el parámetro del bloque catch. Finalmente se ejecutará siempre después de probar y atrapar bloques si hay una excepción planteada o no.

Answer 10

Generalmente cuando usamos cualquier recurso como streams, conexiones, etc., tenemos que cerrarlos explícitamente usando finally block. En el programa que se incluye a continuación, estamos leyendo datos de un archivo usando FileReader y lo estamos cerrando usando finally block.

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

} 

Quizás otros tipos como yo buscamos algo como esto.

La información de esta página tutpoint