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,catchyfinallyson las tres palabras clave con las que Java maneja las excepciones.tryenvuelve el código que puede fallar,catchcaptura el error y decide qué hacer, yfinallyse ejecuta siempre, haya error o no.
Vídeo explicativo
Contenido rápido
tryencierra el código que puede lanzar una excepción.catchcaptura un tipo concreto de excepción y la maneja.finallyse 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 alcatch.catch: recibe la excepción en una variable (e). Cone.getMessage()obtienes el mensaje y cone.printStackTrace()la traza completa.finally: es opcional. Untrynecesita al menos uncatcho unfinally.
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
| Checked | Unchecked | |
|---|---|---|
| Heredan de | Exception | RuntimeException |
| El compilador obliga a manejarlas | Sí: try-catch o throws | No |
| Ejemplos | IOException, SQLException | NullPointerException, IllegalArgumentException |
| Representan | Fallos externos previsibles | Errores 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
catchvacío: el error desaparece y nadie se entera. Como mínimo, regístralo. - Capturar
Exceptionen 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 elif. - Poner un
returnenfinally: sustituye al valor devuelto por eltryy 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.