Esta ocasión vengo a hablar sobre los bloques try, catch y finally de Java.

En el capítulo anterior hablé sobre los tipos de excepciones de Java y puse un ejemplo con cada tipo. En este, vas a ver como manejar las excepciones para que tus programas tengan salidas alternativas en caso de fallar de alguna manera con estos nuevos bloques que todavía no había mostrado en el curso.

El bloque try de Java

En Java, el bloque try se utiliza para envolver un conjunto de instrucciones que pueden lanzar una excepción. Esto se usa para controlar los errores y manejarlos de manera adecuada en tiempo de ejecución.

Es obligatorio que este bloque venga siempre o bien con un bloque catch o con un finally.

El try lo que hace es intentar ejecutar el código con normalidad. Si algo dentro de este código suelta una excepción, lo podremos manejar con un bloque catch.

try {
  // Código que podría generar una excepción
}

Si el código del try no lanza una excepción, se va a ejecutar con total normalidad y se ignorará el código alternativo expuesto en el bloque catch.

El bloque catch de Java

El bloque catch, entonces, se emplea para dar una posible solución a una excepción ocurrida en un bloque try.

Esta sería la sintaxis básica:

try {
  // Código que podría generar una excepción
} catch (tipoExcepción nombreVariable) {
  // Código que se ejecutará si se produce una excepción del tipo especificado
}

Veamos algún ejemplo práctico con estos dos bloques.


El siguiente código se utiliza para leer un archivo de texto plano con Java. El código es correcto, pero como se trata de una excepción comprobada, el compilador nos obliga a manejar la excepción por si el archivo no existe, tiene otro nombre o no se puede abrir por algún motivo.

import java.io.*;

public class Main {
    public static void main(String[] args) {
        FileReader archivo = new FileReader("./src/archivo.txt");
    }
}

Al ejecutar esto sin manejar, nos da el siguiente error:

Error

java: unreported exception java.io.FileNotFoundException; must be caught or declared to be thrown

Nos dice precisamente que hay que manejar la excepción FileNotFoundException.

import java.io.*;

public class Main {
    public static void main(String[] args) {
        try {
            FileReader archivo = new FileReader("./src/archivo.txt");
          	System.out.println("Se leyó el archivo.");
        } catch (Exception e) {
            System.out.println("No se pudo abrir el archivo.");
        }
    }
}

En el try ponemos la parte que puede provocar esa excepción y en catch, un código que se ejecutará solo en caso de que falle el código del try.

La ruta del archivo apunta a la raíz del proyecto, así que si tienes ahí un archivo llamado «archivo.txt» en «src». Lo leerá. No hará nada con él, ya que solo estamos intentando leerlo con Java, no imprimir lo que contiene ni modificarlo. Eso sí, al menos veremos el println() que he puesto para saber que lo ha leído.

Por lo tanto, si ejecutas y no sale ningún error en la consola, es que se ha ejecutado el código del try sin problemas.

Ahora, voy a poner mal el nombre del archivo y ruta, para que no lo encuentre:

FileReader archivo = new FileReader("noexiste.txt");

Resultado

No se pudo abrir el archivo.

¡Perfecto! Hemos conseguido manejar la excepción.

¿Qué es mejor? ¿El uso de Exception o excepciones concretas?

Aunque verás más adelante que las excepciones, es mejor manejarlas de manera concreta para cada tipo de fallo. Veremos algún ejemplo en otro capítulo. De momento, con Exception en el catch, estamos indicando que se manejen de la misma forma todas las posibles excepciones que ocurran. Eso, normalmente, no es lo mejor, ya que es más apropiado dar soluciones concisas y dedicadas a cada tipo de problema que pueda surgir.

El bloque finally de Java

El bloque finally de Java es opcional. Es un bloque adicional que se puede añadir para ejecutar un trozo de código siempre, independientemente de si se ejecuta el try o se ejecuta el catch.

import java.io.*;

public class Main {
    public static void main(String[] args) {
        try {
            FileReader archivo = new FileReader("./src/archivo.txt");
            System.out.println("Se leyó el archivo.");
        } catch (Exception e) {
            System.out.println("No se pudo abrir el archivo.");
        } finally {
            System.out.println("Independientemente de como le haya ido con el archivo, espero que tenga un buen día :D");
        }
    }
}

Esta vez, la ruta es correcta, por lo que se ejecuta el bloque try y luego el finally:

Resultado

Se leyó el archivo.
Independientemente de como le haya ido con el archivo, espero que tenga un buen día 😀

En cambio, si ponemos la ruta mal o el nombre:

Resultado

No se pudo abrir el archivo.
Independientemente de como le haya ido con el archivo, espero que tenga un buen día 😀

Seguiré tratando el tema del manejo de excepciones con los bloques try, catch y finally de Java a medida que lo vayamos necesitando en más ejemplos.

No te pierdas nada del curso de Java, Kotlin y Android Studio.


Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Trending