Bloque Try Catch en Java

Bloque Try Catch

• La instrucción try contiene un bloque de código que se ejecutará de forma “segura” en caso de que ocurra un error esperado.

• La instrucción catch define un bloque de código que se ejecutará si se produce un error en el bloque try. Por lo tanto, la aplicación puede manejar esa situación y evitar propagar la excepción para bloquear la aplicación.

try{
   //Su código que podría lanzar una excepción
}catch (Exception exception){
  // Manejar el error aquñi
}

Debido a que durante la ejecución del bloque try, podemos tener más de una causa diferente de una excepción, el try puede tener más de un bloque catch.

try{
  //Su código que podría lanzar una excepción
} catch (FileNotFoundException ex){
  //Código que maneja File Not Found Exception
} catch (IlegalArgumentException ex){
  //Código que maneja IlegalArgument Exception
} catch (NumberFormatException ex) {
  //Código que maneja NumberFormatException Exception
}

Al agregar más de un bloque catch, el orden es importante. Así que se debe asegurar de agregar primero las excepciones más específicas y, finalmente, las excepciones más genéricas. De lo contrario, si se detecta una excepción genérica se declara primero ocultará las otras.

try{
  //Su código que podría lanzar una excepción
} catch (Exception ex){
  //Código que maneja la excepción de tipo Exception
} catch (IlegalArgumentException ex){
  //Oculto por el catch(Exception). Este código nunca será alzanzado.
} catch (NumberFormatException ex) {
  //Oculto por el catch(Exception). Este código nunca será alzanzado.
}

Bloque Finally

Un bloque de try/catch puede incluir un bloque finally al final. El propósito del bloque “finally” es ejecutarse siempre, una vez que el bloque try finaliza.

No importa si se produce una excepción o no, ni si se llama internamente a una instrucción return, continue o break. El bloque finally se ejecuta siempre. Incluso, si se lanza una excepción inesperada en el bloque catch, se ejecutará el bloque finally y luego se propagará la excepción.

Nota: La única excepción a la regla que el finally siempre es ejecuta es si la aplicación se termina mientras ejecutada algún código dentro del bloque try. Eso puede suceder porque se llama al método System.exit, o se envía una señal KILL or TERM desde el sistema operativo.

El bloque finally es muy útil para limpiar el código después de que finaliza el bloque try, podría usarse para liberar recursos (conexiones, archivos). Por lo tanto, es una buena práctica agregarlo incluso cuando no se prevén excepciones.

try{
  //Su código que podría lanzar una excepción
} catch (exception MyException){
  //Manejar la excepción aquí
} finally {
  //Liberar recursos aquí
}

Nota: El bloque try permite tener un bloque finally sin un bloque catch, en otras palabras, un bloque de try/finally. Por lo tanto, algo como: try{//my code} finally {//release resources} es válido…

Bloque Multi-catch

Como hemos visto, el bloque try permite tener más de un bloque catch. ¿Qué pasa si tenemos múltiples excepciones que podrían manejarse de la misma manera?

Para estos casos, podemos usar el bloque multi-catch.

try{
  //Su código que puede causar una excepción
} catch (IOException | SQLException | FileNotFoundException exc){
  //Código que maneja las excepciones IOException o SQLException o FileNotFoundException
  System.error("The application was not ready because "+exc.getMessage());
} catch (NumberFormatException ex) {
  //Código que maneja la excepción NumberFormatException
  System.error("The value of xxx is not a number");
}

Podemos reducir la cantidad de código duplicado para manejar excepciones.

Bloque Try With Resources

El try-with-resources es otra característica útil para reemplazar el uso del bloque try/catch/finally en los casos en que es necesario crear recursos y usarlos durante el bloque try y liberarlos durante el bloque finally. Si ese recurso implementa la interfaz Closable o AutoClosable, el bloque llamará al método close() automáticamente cuando finalice el try.

Por lo tanto, ya no es necesario agregar manualmente esas llamadas al método close() en el bloque finally.

try (Statement stmt = con.createStatement()) {
  //Código que usa el recurso
} 

Permite inicializar o definir más de un recurso, todos ellos separados por punto y coma ; . En ese caso, los recursos que se definieron/adquirieron primero se cerrarán en último lugar. Además, en Java 9 o versiones posteriores, los recursos se pueden inicializar antes del try o al definirse el try.

final Statement stmt = con.createStatement();
final BufferedWriter writer = Files.newBufferedWriter(outputFilePath, charset)
try (stmt; writer) {
  //Your code
} 

Un bloque try-with-resources puede aun tener los bloques catch y finally, los cuales van a trabajar de la misma manera como en el bloque try tradicional. A esto se le conoce como un “try-with-resources extendido“

try (Statement stmt = con.createStatement();
     BufferedWriter writer = Files.newBufferedWriter(outputFilePath, charset)) {
  //Su código
} catch (SQLException | IOException ex){
  //Manejar el error
} finally{
  System.out.println("Finally ha sido llamado!");
}

Sin embargo, es importante saber qué el “finally generado” que cierra los recursos se ejecutará justo después del try y antes de los bloques extra “catch/finally”. Luego, se ejecutará los bloques explícitos “catch” o “finally”.

Referencias

• https://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html
• https://beginnersbook.com/2013/04/try-catch-in-java/
• https://www.w3schools.com/java/java_try_catch.asp
• https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
• https://www.baeldung.com/java-try-with-resources
• https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.20.3.2