Artículo

Try, catch y finally en Java: manejo de excepciones

try, catch y finally en Java: cómo capturar excepciones, varios catch, try-with-resources, checked vs unchecked y excepciones propias, con ejemplos.

Try, catch y finally en Java: manejo de excepciones

try, catch y finally son las tres palabras clave con las que Java maneja las excepciones. try envuelve el código que puede fallar, catch captura el error y decide qué hacer, y finally se ejecuta siempre, haya error o no.

Vídeo explicativo

Contenido rápido

  • try encierra el código que puede lanzar una excepción.
  • catch captura un tipo concreto de excepción y la maneja.
  • finally se ejecuta siempre: sirve para liberar recursos.
  • try-with-resources cierra los recursos por ti y sustituye a casi todos los finally.
  • Las excepciones checked obligan a capturarlas o declararlas con throws; las unchecked no.

¿Qué es una excepción?

Una excepción es un objeto que Java crea cuando algo va mal durante la ejecución: dividir entre cero, abrir un fichero que no existe, usar una referencia null. Si nadie la captura, el programa se detiene y muestra la traza del error. Con try-catch decides tú qué ocurre.

Cómo usar try-catch

static int dividir(int a, int b) {
    try {
        return a / b;
    } catch (ArithmeticException e) {
        System.out.println("Error: " + e.getMessage());
        return 0;
    } finally {
        System.out.println("Fin de la división");
    }
}

dividir(10, 2) imprime Fin de la división y devuelve 5. dividir(5, 0) imprime:

Error: / by zero
Fin de la división

y devuelve 0. Fíjate en que finally se ejecuta en los dos casos, incluso cuando hay un return dentro del try.

  • try: si una línea lanza una excepción, las siguientes líneas del bloque no se ejecutan y el control salta al catch.
  • catch: recibe la excepción en una variable (e). Con e.getMessage() obtienes el mensaje y con e.printStackTrace() la traza completa.
  • finally: es opcional. Un try necesita al menos un catch o un finally.

Capturar varias excepciones

Varios bloques catch

Cada catch maneja un tipo. Java los evalúa en orden y ejecuta solo el primero que coincide:

try {
    // código que puede lanzar varias excepciones
} catch (ArithmeticException e) {
    // error aritmético
} catch (NullPointerException e) {
    // referencia nula
} catch (Exception e) {
    // cualquier otra excepción
}

El orden importa: ve de lo más específico a lo más general. Si pones catch (Exception e) el primero, los demás nunca se alcanzan y el código no compila.

Multi-catch con |

Desde Java 7 puedes tratar varios tipos con el mismo código:

static void mostrarInverso(String texto) {
    try {
        int numero = Integer.parseInt(texto);
        System.out.println(10 / numero);
    } catch (NumberFormatException | ArithmeticException e) {
        System.out.println("Entrada no válida: " + e.getMessage());
    }
}

Con "abc" imprime Entrada no válida: For input string: "abc", y con "0", Entrada no válida: / by zero.

Capturar Exception

catch (Exception e) captura cualquier excepción. Es cómodo, pero esconde errores que no esperabas. Úsalo solo en el nivel más alto de la aplicación, para registrar el error, y captura tipos concretos en el resto.

try-with-resources

Los recursos que hay que cerrar (ficheros, conexiones de base de datos, sockets) se declaran entre paréntesis después de try. Java los cierra al salir del bloque, haya error o no:

static String primeraLinea(Path ruta) throws IOException {
    try (BufferedReader lector = Files.newBufferedReader(ruta)) {
        return lector.readLine();
    }
}

Funciona con cualquier clase que implemente AutoCloseable. Es más corto y más seguro que cerrar a mano en un finally.

Excepciones checked y unchecked

CheckedUnchecked
Heredan deExceptionRuntimeException
El compilador obliga a manejarlasSí: try-catch o throwsNo
EjemplosIOException, SQLExceptionNullPointerException, IllegalArgumentException
RepresentanFallos externos previsiblesErrores de programación

En el ejemplo anterior, primeraLinea declara throws IOException porque es checked: quien la llame tendrá que capturarla o declararla también.

throw y excepciones personalizadas

Con throw lanzas tú una excepción. Para errores de tu dominio, crea una clase propia:

class SaldoInsuficienteException extends RuntimeException {
    SaldoInsuficienteException(String mensaje) {
        super(mensaje);
    }
}

static void retirar(double saldo, double cantidad) {
    if (cantidad > saldo) {
        throw new SaldoInsuficienteException("Saldo insuficiente: faltan " + (cantidad - saldo));
    }
}

retirar(100, 150) lanza la excepción con el mensaje Saldo insuficiente: faltan 50.0.

Errores habituales

  • Dejar el catch vacío: el error desaparece y nadie se entera. Como mínimo, regístralo.
  • Capturar Exception en todas partes: tratas igual un fichero que falta y un fallo de programación.
  • Usar excepciones como control de flujo: si puedes comprobarlo con un if, usa el if.
  • Poner un return en finally: sustituye al valor devuelto por el try y oculta la excepción.

Preguntas frecuentes

¿Qué es try-catch en Java?

Es el mecanismo de manejo de excepciones. El bloque try contiene el código que puede fallar y el bloque catch captura la excepción y la maneja. Si ocurre un error en el try, la ejecución salta al catch correspondiente.

¿Qué es finally en Java?

Un bloque opcional que se ejecuta siempre, haya ocurrido una excepción o no. Se usa para liberar recursos como ficheros o conexiones.

¿finally se ejecuta aunque haya un return?

Sí. Se ejecuta antes de que el método devuelva el valor. Solo se salta si la JVM termina, por ejemplo con System.exit().

¿Cuál es la diferencia entre throw y throws?

throw lanza una excepción dentro de un método: throw new IOException("error"). throws va en la firma del método y declara que puede lanzarla: void leer() throws IOException.

¿Cómo se crea una excepción personalizada?

Con una clase que extienda Exception (checked) o RuntimeException (unchecked) y un constructor que pase el mensaje a super.

Artículos relacionados

Ejecuta este ejemplo sin instalar nada: try, catch y finally en Java: ejemplo ejecutable

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo