Una grieta en setPrecio
En la lección de constructores, setPrecio devolvía false al rechazar un precio negativo. Pero nada obliga a quien lo llama a mirar ese resultado. El precio queda como estaba, sin aviso, y el programa sigue como si nada.
El archivo no está
FileNotFoundException La red se cae
SocketException El usuario escribe "veintidós"
NumberFormatException La base rechaza la conexión
SQLException ¿Qué hace tu código cuando falla?
try
Se corta en la línea que falla
catch
Corre solo si el tipo coincide
finally
Corre siempre, incluso con return
Lo que sigue
El programa continúa normalmente
Unchecked · RuntimeException
Errores de programación
Se evitan, no se manejan. El compilador no dice nada.
Checked · Exception
Condiciones del entorno
Esperables y fuera de tu control. El compilador te obliga a decidir.
throw
Una acción
throw new EdadInvalidaException(edad); throws
Una advertencia
void setEdad(int e) throws EdadInvalidaException No donde ocurre
Leer un archivo casi nunca sabe qué hacer si no existe.
Donde podés decidir
El que mandó a leer sabe si reintentar, avisar o usar un valor por defecto.
Un catch que sobra
Si no puede tomar ninguna decisión útil, no lo escribas.
Orden
De lo específico a lo general
Si invertís el orden, el compilador te frena.
multi-catch
catch (IOException | SQLException e) Un solo bloque cuando dos tipos se manejan igual.
A mano
Nueve líneas de ceremonia
null check, close() que también puede fallar y casi nadie sabe qué poner.
AutoCloseable
Un recurso simulado
Imprime un mensaje al abrirse y otro al cerrarse.
try-with-resources
El cierre ya no depende de vos
Funciona con cualquier clase AutoCloseable.
Excepción del dominio
SaldoInsuficienteException Te dice qué pasó desde el nombre.
Lleva datos
e.getFaltante() No solo un texto: el catch puede usarlos.
extends Exception · checked
Condición esperable del entorno: archivo de configuración no encontrado.
extends RuntimeException · unchecked
Error de uso de la API: el llamador debió validar antes. Lo más común hoy.
1 El catch vacío
Un error tragado es infinitamente peor que uno visible.
2 Capturar Exception de entrada
Atrapa también los bugs que debían explotar temprano.
3 Control de flujo normal
Que un usuario no exista no es excepcional, es martes.
4 return dentro de finally
Descarta en silencio la excepción que viajaba.
1 Paso
EdadInvalidaException
extends RuntimeException + edad rechazada
2 Paso
registrar(nombre, edad)
La regla del rango, en un solo lugar
3 Paso
registrarDesdeTexto(…)
Traduce NumberFormatException, conserva la causa
4 Paso
main
Caso válido, fuera de rango y texto inválido
5 Paso
finally
Constancia de que el intento terminó
CursoDeJava · l12_excepciones_y_manejo_de_errores
16 ejercicios: de la división sin control a las excepciones propias
En la lección de constructores, setPrecio devolvía false al rechazar un precio negativo.
Pero nada obliga a quien lo llama a mirar ese resultado.
El precio queda como estaba, sin aviso, y el programa sigue como si nada.
En la lección de constructores, setPrecio devolvía false al rechazar un precio negativo. Pero nada obliga a quien lo llama a mirar ese resultado. El precio queda como estaba, sin aviso, y el programa sigue como si nada.
Con una excepción, setPrecio lanza un objeto que describe el problema.
La ejecución normal se interrumpe hasta que alguien lo atrape.
Si nadie lo atrapa, el programa se detiene: no hay forma de fingir que no pasó nada.
Con una excepción, setPrecio lanza un objeto que describe el problema. La ejecución normal se interrumpe hasta que alguien lo atrape. Si nadie lo atrapa, el programa se detiene: no hay forma de fingir que no pasó nada.
El archivo no está, la red se cae, el usuario escribe "veintidós" donde iba un número.
La pregunta no es si va a fallar, sino qué hace tu código cuando falla.
El archivo no está, la red se cae, el usuario escribe "veintidós" donde iba un número. La pregunta no es si va a fallar, sino qué hace tu código cuando falla.
Todo lo que se puede lanzar cuelga de Throwable, la raíz de la jerarquía.
Debajo hay dos ramas: Error, para fallas de la JVM, y Exception.
Y de Exception cuelga RuntimeException, con sus hijas.
Todo lo que se puede lanzar cuelga de Throwable, la raíz de la jerarquía. Debajo hay dos ramas: Error, para fallas de la JVM, y Exception. Y de Exception cuelga RuntimeException, con sus hijas.
Exception sin RuntimeException es CHECKED: el compilador te obliga a hacerte cargo.
Todo lo que cuelga de RuntimeException es UNCHECKED: el compilador no dice nada.
Exception sin RuntimeException es CHECKED: el compilador te obliga a hacerte cargo. Todo lo que cuelga de RuntimeException es UNCHECKED: el compilador no dice nada.
Un Error, como OutOfMemoryError, no se captura: no hay nada que puedas hacer.
Si la JVM se quedó sin memoria, tu catch tampoco va a poder ejecutarse.
Un Error, como OutOfMemoryError, no se captura: no hay nada que puedas hacer. Si la JVM se quedó sin memoria, tu catch tampoco va a poder ejecutarse.
Una excepción no es un código de error: es una instancia de una clase.
getMessage() devuelve la descripción y getCause() la excepción original, si hay.
getStackTrace() guarda el recorrido y printStackTrace() lo imprime en la salida de error.
Una excepción no es un código de error: es una instancia de una clase. getMessage() devuelve la descripción y getCause() la excepción original, si hay. getStackTrace() guarda el recorrido y printStackTrace() lo imprime en la salida de error.
El try contiene el código que puede fallar.
El catch atrapa la excepción, si el tipo coincide.
El finally corre sí o sí, y después sigue el programa.
El try contiene el código que puede fallar. El catch atrapa la excepción, si el tipo coincide. El finally corre sí o sí, y después sigue el programa.
Sin excepción, el try se ejecuta entero, hasta la última línea.
El catch se saltea por completo: no hubo nada que atrapar.
El finally corre igual y el programa continúa normalmente.
Sin excepción, el try se ejecuta entero, hasta la última línea. El catch se saltea por completo: no hubo nada que atrapar. El finally corre igual y el programa continúa normalmente.
Ahora el divisor es cero: el try se CORTA en esa línea.
Las líneas siguientes nunca se ejecutan: la B no aparece en la salida.
La excepción viaja al catch; después corre el finally y sigue el código.
Ahora el divisor es cero: el try se CORTA en esa línea. Las líneas siguientes nunca se ejecutan: la B no aparece en la salida. La excepción viaja al catch; después corre el finally y sigue el código.
Incluso con un return dentro del try, el finally se ejecuta antes de salir.
Lo que no corre es el código que quedaba después: el método ya terminó.
Incluso con un return dentro del try, el finally se ejecuta antes de salir. Lo que no corre es el código que quedaba después: el método ya terminó.
Salida: A, C, D. La línea B jamás se ejecuta.
Por eso conviene que los bloques try sean cortos: un try de cuarenta líneas es un misterio.
Salida: A, C, D. La línea B jamás se ejecuta. Por eso conviene que los bloques try sean cortos: un try de cuarenta líneas es un misterio.
public class Flujo {public static void main(String[] args) {try {System.out.println("A");int x = 10 / 0; // ← acá se lanzaSystem.out.println("B"); // ← NUNCA se ejecuta} catch (ArithmeticException e) {System.out.println("C");}System.out.println("D");}} java FlujoACD Las unchecked son errores de programación: un NullPointerException se evita, no se maneja.
El compilador no pone ninguna barrera: pasan de largo.
La solución no es un catch, es arreglar el código.
Las unchecked son errores de programación: un NullPointerException se evita, no se maneja. El compilador no pone ninguna barrera: pasan de largo. La solución no es un catch, es arreglar el código.
Las checked son condiciones esperables del entorno: el archivo no está, el servicio no responde.
Acá el compilador frena el paso y te obliga a decidir.
Las checked son condiciones esperables del entorno: el archivo no está, el servicio no responde. Acá el compilador frena el paso y te obliga a decidir.
Solo hay dos opciones. Manejarla con try/catch…
…o declarar con throws que no te hacés cargo, y que lo decida quien te llamó.
Solo hay dos opciones. Manejarla con try/catch… …o declarar con throws que no te hacés cargo, y que lo decida quien te llamó.
NullPointerException, ArrayIndexOutOfBoundsException, NumberFormatException: todas son unchecked.
El bug es el null, el índice 5 o la entrada sin validar, no la excepción.
NullPointerException, ArrayIndexOutOfBoundsException, NumberFormatException: todas son unchecked. El bug es el null, el índice 5 o la entrada sin validar, no la excepción.
String s = null;s.length(); // NullPointerException — el bug es el nullint[] a = new int[3];a[5] = 1; // ArrayIndexOutOfBoundsException — el bug es el 5Integer.parseInt("hola"); // NumberFormatException — validá la entrada antes Scanner.nextInt() lanza InputMismatchException: es unchecked, hereda de RuntimeException.
Cuando falla, el texto inválido sigue en el buffer: sin nextLine() el bucle falla una y otra vez.
Scanner.nextInt() lanza InputMismatchException: es unchecked, hereda de RuntimeException. Cuando falla, el texto inválido sigue en el buffer: sin nextLine() el bucle falla una y otra vez.
Scanner leer = new Scanner(System.in);int edad = 0;boolean valido = false;while (!valido) {try {edad = leer.nextInt(); // InputMismatchException si escriben "abc"valido = true;} catch (InputMismatchException e) {System.out.println("Ingresá un número.");leer.nextLine(); // descarta el texto inválido del buffer}} java EdadabcIngresá un número.22(la edad es 22) obtenerConfiguracion() declara throws ConfiguracionNoDisponibleException: es checked.
O la manejás con un catch, o la declarás en tu firma y que decida quien te llamó.
obtenerConfiguracion() declara throws ConfiguracionNoDisponibleException: es checked. O la manejás con un catch, o la declarás en tu firma y que decida quien te llamó.
// Opción 1: manejarlapublic void leerConfiguracion() {try {String valor = obtenerConfiguracion();System.out.println(valor);} catch (ConfiguracionNoDisponibleException e) {System.out.println("Uso los valores por defecto.");}} // Opción 2: declarar que no te hacés cargopublic String leerConfiguracion() throws ConfiguracionNoDisponibleException {return obtenerConfiguracion(); // que decida el de arriba} throw es una acción: lanza el objeto, dentro del método.
throws es una advertencia: va en la firma y avisa qué puede salir.
throw es una acción: lanza el objeto, dentro del método. throws es una advertencia: va en la firma y avisa qué puede salir.
public void setEdad(int edad) throws EdadInvalidaException { // throws: advertenciaif (edad < 0) {throw new EdadInvalidaException(edad); // throw: acción}this.edad = edad;} Cada llamada apila un frame: main llama a procesarArchivo, que llama a leerLinea…
…que al final llama a Integer.parseInt con el texto "veintidós".
Cada llamada apila un frame: main llama a procesarArchivo, que llama a leerLinea… …que al final llama a Integer.parseInt con el texto "veintidós".
parseInt no puede convertir "veintidós" y lanza un NumberFormatException.
La excepción nace acá, en el frame de más arriba.
parseInt no puede convertir "veintidós" y lanza un NumberFormatException. La excepción nace acá, en el frame de más arriba.
Este frame no tiene catch: se abandona y su código restante no se ejecuta.
La excepción pasa al método que lo llamó, leerLinea, que tampoco la atrapa.
Y sigue: procesarArchivo tampoco sabe qué hacer con ella.
Este frame no tiene catch: se abandona y su código restante no se ejecuta. La excepción pasa al método que lo llamó, leerLinea, que tampoco la atrapa. Y sigue: procesarArchivo tampoco sabe qué hacer con ella.
En main hay un catch cuyo tipo coincide: acá la excepción se detiene.
Se ejecuta el handler y el programa sigue como si nada.
En main hay un catch cuyo tipo coincide: acá la excepción se detiene. Se ejecuta el handler y el programa sigue como si nada.
Ese recorrido queda registrado en el stack trace de la excepción.
Cada línea es un frame: de dónde nació y por quiénes pasó hasta el catch.
Ese recorrido queda registrado en el stack trace de la excepción. Cada línea es un frame: de dónde nació y por quiénes pasó hasta el catch.
Si nadie la atrapa, llega al final de la pila y la JVM imprime el stack trace.
El hilo termina: una excepción sin atrapar no se puede ignorar.
Si nadie la atrapa, llega al final de la pila y la JVM imprime el stack trace. El hilo termina: una excepción sin atrapar no se puede ignorar.
No tenés que capturar donde ocurre el error, sino donde podés hacer algo con él.
Un método que lee un archivo casi nunca sabe qué hacer si no existe; el que lo mandó a leer, sí.
Un catch que no puede tomar ninguna decisión útil es un catch que sobra.
No tenés que capturar donde ocurre el error, sino donde podés hacer algo con él. Un método que lee un archivo casi nunca sabe qué hacer si no existe; el que lo mandó a leer, sí. Un catch que no puede tomar ninguna decisión útil es un catch que sobra.
Java prueba los catch en orden y ejecuta el primero cuyo tipo coincide.
Una NumberFormatException cae en el primero: es el más específico.
Java prueba los catch en orden y ejecuta el primero cuyo tipo coincide. Una NumberFormatException cae en el primero: es el más específico.
Una IllegalArgumentException pasa de largo el primero y cae en el segundo.
Y cualquier otra, como IOException, termina en el catch (Exception e) final.
Una IllegalArgumentException pasa de largo el primero y cae en el segundo. Y cualquier otra, como IOException, termina en el catch (Exception e) final.
Si ponés Exception primero, atrapa todo y los catch de abajo nunca podrían correr.
El compilador te frena: error de compilación, catch inalcanzable.
Si ponés Exception primero, atrapa todo y los catch de abajo nunca podrían correr. El compilador te frena: error de compilación, catch inalcanzable.
Cuando dos tipos distintos se manejan igual, no dupliques el bloque.
Con multi-catch, IOException | SQLException, un solo catch atrapa a las dos.
Cuando dos tipos distintos se manejan igual, no dupliques el bloque. Con multi-catch, IOException | SQLException, un solo catch atrapa a las dos.
Los catch van de lo más específico a lo más general.
Y el multi-catch evita duplicar el bloque cuando dos tipos se manejan igual.
Los catch van de lo más específico a lo más general. Y el multi-catch evita duplicar el bloque cuando dos tipos se manejan igual.
try {procesar(datos);} catch (NumberFormatException e) { // más específica primeroSystem.out.println("El dato no es un número válido.");} catch (IllegalArgumentException e) { // NumberFormatException hereda de estaSystem.out.println("Argumento inválido.");} catch (Exception e) { // la más general, al finalSystem.out.println("Error inesperado.");} try {conectarYGuardar();} catch (IOException | SQLException e) { // multi-catchlogger.error("Falló la persistencia: " + e.getMessage());} Abrir un archivo o una conexión obliga a cerrarlo, sobre todo si algo falla en el medio.
Hacerlo a mano son nueve líneas de ceremonia y dos casos borde que casi todos olvidan.
Abrir un archivo o una conexión obliga a cerrarlo, sobre todo si algo falla en el medio. Hacerlo a mano son nueve líneas de ceremonia y dos casos borde que casi todos olvidan.
ConexionSimulada conexion = null;try {conexion = new ConexionSimulada("servidor-datos");conexion.enviar("SELECT * FROM productos");} catch (IllegalArgumentException e) {System.out.println("No se pudo conectar.");} finally {if (conexion != null) { // ¿y si falló al construirla?try {conexion.close(); // cerrar también puede lanzar excepción} catch (Exception e) {// y acá casi nadie sabe qué poner}}} Para ver el mecanismo sin archivos, simulamos un recurso que implementa AutoCloseable.
Imprime un mensaje al abrirse y otro al cerrarse, así se ve el orden exacto.
Para ver el mecanismo sin archivos, simulamos un recurso que implementa AutoCloseable. Imprime un mensaje al abrirse y otro al cerrarse, así se ve el orden exacto.
public class ConexionSimulada implements AutoCloseable {private final String servidor; public ConexionSimulada(String servidor) {if (servidor == null || servidor.isBlank()) {throw new IllegalArgumentException("El servidor no puede estar vacío");}this.servidor = servidor;System.out.println("Conectando a " + servidor + "...");} public void enviar(String comando) {System.out.println("Enviando: " + comando);} @Overridepublic void close() {System.out.println("Conexión a " + servidor + " cerrada.");}} En try-with-resources el recurso se declara dentro del paréntesis del try.
Se abre al entrar y se usa dentro del bloque: "Conectando…", "Enviando…".
Y se cierra solo, aunque no lo escribas: Java llama a close() por vos.
En try-with-resources el recurso se declara dentro del paréntesis del try. Se abre al entrar y se usa dentro del bloque: "Conectando…", "Enviando…". Y se cierra solo, aunque no lo escribas: Java llama a close() por vos.
Un bloque puede terminar de tres maneras: bien, con una excepción o con un return.
Los tres caminos convergen en el mismo punto: close() corre siempre.
Corre antes del catch o del finally. No hay forma de olvidarlo.
Un bloque puede terminar de tres maneras: bien, con una excepción o con un return. Los tres caminos convergen en el mismo punto: close() corre siempre. Corre antes del catch o del finally. No hay forma de olvidarlo.
Un solo bloque, sin finally ni null checks: el cierre ya no depende de vos.
Funciona con cualquier clase AutoCloseable, y podés declarar varios recursos con punto y coma.
Un solo bloque, sin finally ni null checks: el cierre ya no depende de vos. Funciona con cualquier clase AutoCloseable, y podés declarar varios recursos con punto y coma.
try (ConexionSimulada conexion = new ConexionSimulada("servidor-datos")) {conexion.enviar("SELECT * FROM productos");} catch (IllegalArgumentException e) {System.out.println("No se pudo conectar.");}// conexion ya está cerrada, pase lo que pase java ConTryWithResourcesConectando a servidor-datos...Enviando: SELECT * FROM productosConexión a servidor-datos cerrada. Cuando el problema es de tu dominio, las excepciones estándar no lo describen bien.
SaldoInsuficienteException te dice qué pasó desde el nombre.
Cuando el problema es de tu dominio, las excepciones estándar no lo describen bien. SaldoInsuficienteException te dice qué pasó desde el nombre.
// Unchecked: el llamador puede prevenirlo consultando el saldo antespublic class SaldoInsuficienteException extends RuntimeException {private final double faltante; public SaldoInsuficienteException(double solicitado, double disponible) {super(String.format("Faltan $%.2f: se pidieron $%.2f y hay $%.2f",solicitado - disponible, solicitado, disponible));this.faltante = solicitado - disponible;} public double getFaltante() { return faltante; }} Fijate que la excepción lleva datos, no solo un texto.
El catch los usa: e.getFaltante() permite decidir qué mostrarle al usuario.
Fijate que la excepción lleva datos, no solo un texto. El catch los usa: e.getFaltante() permite decidir qué mostrarle al usuario.
try {cuenta.retirar(5000);} catch (SaldoInsuficienteException e) {System.out.printf("Te faltan $%.2f. ¿Querés cargar saldo?%n", e.getFaltante());} java RetiroTe faltan $1500,00. ¿Querés cargar saldo? La pregunta que decide: ¿quien llama puede hacer algo razonable para recuperarse?
Si es una condición esperable del entorno, extends Exception: checked.
Si es un error de uso de la API, extends RuntimeException: unchecked, y es lo más común hoy.
La pregunta que decide: ¿quien llama puede hacer algo razonable para recuperarse? Si es una condición esperable del entorno, extends Exception: checked. Si es un error de uso de la API, extends RuntimeException: unchecked, y es lo más común hoy.
Al traducir una excepción de bajo nivel a una de tu dominio, no pierdas la original.
El segundo argumento, e, es la causa: queda guardada dentro de la nueva excepción.
Así el stack trace completo sigue disponible para depurar.
Al traducir una excepción de bajo nivel a una de tu dominio, no pierdas la original. El segundo argumento, e, es la causa: queda guardada dentro de la nueva excepción. Así el stack trace completo sigue disponible para depurar.
Si relanzás con e.getMessage() en lugar de e, la causa se pierde.
El stack trace se corta justo donde estaba la línea que falló de verdad.
Si relanzás con e.getMessage() en lugar de e, la causa se pierde. El stack trace se corta justo donde estaba la línea que falló de verdad.
El catch vacío: la excepción entra y desaparece sin dejar rastro.
El pedido no se guardó, el usuario ve "listo" y no hay nada en ningún log.
Un error tragado es infinitamente peor que un error visible.
El catch vacío: la excepción entra y desaparece sin dejar rastro. El pedido no se guardó, el usuario ve "listo" y no hay nada en ningún log. Un error tragado es infinitamente peor que un error visible.
Un return dentro de finally descarta la excepción que estaba viajando.
Se lanza IllegalStateException, el finally hace return 0 y nadie se entera nunca.
Un return dentro de finally descarta la excepción que estaba viajando. Se lanza IllegalStateException, el finally hace return 0 y nadie se entera nunca.
El catch vacío es el peor: traga el error y no deja ni un log.
Capturar Exception de entrada atrapa también los bugs que querías que explotaran temprano.
Capturá el tipo más específico que sepas manejar.
El catch vacío es el peor: traga el error y no deja ni un log. Capturar Exception de entrada atrapa también los bugs que querías que explotaran temprano. Capturá el tipo más específico que sepas manejar.
Que un usuario no exista no es excepcional, es martes.
Además lanzar excepciones es caro: construirlas implica capturar el stack trace completo.
Que un usuario no exista no es excepcional, es martes. Además lanzar excepciones es caro: construirlas implica capturar el stack trace completo.
// Mal: usa una excepción para algo que pasa todos los díastry {Usuario u = buscarUsuario(email);mostrar(u);} catch (UsuarioNoEncontradoException e) {mostrarFormularioDeRegistro();} // Bien: null expresa "puede no haber" sin ninguna excepciónUsuario u = buscarUsuario(email);if (u != null) {mostrar(u);} else {mostrarFormularioDeRegistro();} Un catch vacío, catch (Exception e) como primero y el catch general antes del específico.
Relanzar con e.getMessage() en vez de pasar la causa, y bloques try de cincuenta líneas.
Cerrar recursos a mano en finally y usar excepciones para casos normales.
Un catch vacío, catch (Exception e) como primero y el catch general antes del específico. Relanzar con e.getMessage() en vez de pasar la causa, y bloques try de cincuenta líneas. Cerrar recursos a mano en finally y usar excepciones para casos normales.
Creá EdadInvalidaException, una RuntimeException que guarda la edad rechazada.
Un método registrar la lanza fuera de 0 a 120; otro convierte texto y traduce el error.
En el main, probá tres casos y dejá constancia en un finally.
Creá EdadInvalidaException, una RuntimeException que guarda la edad rechazada. Un método registrar la lanza fuera de 0 a 120; otro convierte texto y traduce el error. En el main, probá tres casos y dejá constancia en un finally.
Es unchecked porque quien llama puede validar la edad antes: es un error de uso.
El segundo constructor recibe la causa para envolver otra excepción sin perderla.
Es unchecked porque quien llama puede validar la edad antes: es un error de uso. El segundo constructor recibe la causa para envolver otra excepción sin perderla.
public class EdadInvalidaException extends RuntimeException {private final int edadRechazada; public EdadInvalidaException(int edadRechazada) {super("Edad inválida: " + edadRechazada + ". Debe estar entre 0 y 120.");this.edadRechazada = edadRechazada;} // Constructor con causa: para envolver otra excepción sin perderlapublic EdadInvalidaException(String mensaje, Throwable causa) {super(mensaje, causa);this.edadRechazada = -1;} public int getEdadRechazada() { return edadRechazada; }} registrar es el único lugar donde vive la regla del rango.
registrarDesdeTexto traduce el NumberFormatException pero pasa e como causa.
registrar es el único lugar donde vive la regla del rango. registrarDesdeTexto traduce el NumberFormatException pero pasa e como causa.
public class RegistroDePersonas {private static final int EDAD_MINIMA = 0;private static final int EDAD_MAXIMA = 120; public void registrar(String nombre, int edad) {if (nombre == null || nombre.isBlank()) {throw new IllegalArgumentException("El nombre es obligatorio");}if (edad < EDAD_MINIMA || edad > EDAD_MAXIMA) {throw new EdadInvalidaException(edad);}System.out.println(" ✓ Registrado: " + nombre + ", " + edad + " años");} public void registrarDesdeTexto(String nombre, String edadTexto) {int edad;try {edad = Integer.parseInt(edadTexto.trim());} catch (NumberFormatException e) {// Traducimos al lenguaje de NUESTRO dominio, sin perder la causathrow new EdadInvalidaException("'" + edadTexto + "' no es un número válido para una edad", e);}registrar(nombre, edad); // la regla del rango vive en un solo lugar}} Un caso válido, una edad fuera de rango y un texto que no es número.
El finally deja constancia en los tres, y la causa técnica sigue disponible para el log.
Un caso válido, una edad fuera de rango y un texto que no es número. El finally deja constancia en los tres, y la causa técnica sigue disponible para el log.
for (String[] intento : intentos) {System.out.println("Intentando registrar a " + intento[0] + "...");try {registro.registrarDesdeTexto(intento[0], intento[1]);} catch (EdadInvalidaException e) {System.out.println(" ✗ " + e.getMessage());if (e.getCause() != null) {System.out.println(" causa técnica: " + e.getCause());}} catch (IllegalArgumentException e) {System.out.println(" ✗ Dato inválido: " + e.getMessage());} finally {System.out.println(" — intento finalizado —\n");}} java MainRegistroIntentando registrar a Laura Giménez... ✓ Registrado: Laura Giménez, 28 años — intento finalizado —Intentando registrar a Carlos Ruiz... ✗ Edad inválida: 150. Debe estar entre 0 y 120. — intento finalizado —Intentando registrar a Ana Torres... ✗ 'treinta' no es un número válido para una edad causa técnica: java.lang.NumberFormatException: For input string: "treinta" — intento finalizado — Una excepción es un objeto; unchecked se evita, checked te obliga a decidir.
El finally corre siempre, la excepción sube por la pila y try-with-resources cierra por vos.
Al relanzar pasá la causa, y recordá: un catch vacío es peor que no capturar nada.
Una excepción es un objeto; unchecked se evita, checked te obliga a decidir. El finally corre siempre, la excepción sube por la pila y try-with-resources cierra por vos. Al relanzar pasá la causa, y recordá: un catch vacío es peor que no capturar nada.