05 - Control de Errores y Configuración de Aplicaciones

Las excepciones son eventos anómalos que ocurren durante la ejecución de un programa y rompen el flujo normal de las instrucciones. Java proporciona un mecanismo orientado a objetos para capturar y gestionar estos errores de forma controlada.

Todas las excepciones derivan de la clase base java.lang.Throwable, que se divide en dos ramas principales:

ObjectThrowableErrorExceptionRuntimeException

  • Error: Fallos graves e irrecuperables a nivel de entorno o Máquina Virtual (ej. OutOfMemoryError, StackOverflowError). La aplicación no debe intentar capturarlos.

  • Exception: Errores que la aplicación puede (y debe) gestionar:

    • Excepciones Verificadas (Checked Exceptions): Se verifican en tiempo de compilación. El compilador obliga a gestionarlas explícitamente mediante try-catch o a declararlas en la firma del método con throws (ej. IOException, FileNotFoundException). Heredan de Exception

    • Excepciones No Verificadas (Unchecked / RuntimeExceptions): Ocurren en tiempo de ejecución y heredan de RuntimeException. Suelen indicar errores de programación o lógica (ej. NullPointerException, IllegalArgumentException).

La estrategia para gestionar una excepción varía fundamentalmente según si se trata de una excepción verificada (Checked) o no verificada (Unchecked).

Tratamiento de Checked Exceptions: La regla "Catch or Declare"

Dado que el compilador verifica la presencia de estas excepciones, la sintaxis de Java obliga a tomar una de las siguientes dos decisiones ante cualquier instrucción que pueda lanzarlas:

  • Capturar la excepción (try-catch): El método asume la responsabilidad de gestionar el fallo localmente en el momento en que ocurre.

  • Propagar la excepción (throws): El método delega la responsabilidad al nivel superior en la cadena de llamadas, indicando en su firma que puede lanzar dicha excepción.
public class GestorConfiguracion {
 
    // OPCIÓN A: Captura local mediante try-catch
    public void cargarDesdeFicheroLocal() {
        try {
            // FileReader lanza FileNotFoundException (Checked Exception)
            FileReader reader = new FileReader("config.json");
        } catch (FileNotFoundException e) {
            IO.println("Fichero no encontrado. Cargando valores por defecto...");
        }
    }
 
    // OPCIÓN B: Propagación hacia el llamador mediante 'throws'
    public void cargarDesdeFicheroDelegado() throws FileNotFoundException {
        // Se traslada la obligación de tratamiento al método que invoque a 'cargarDesdeFicheroDelegado'
        FileReader reader = new FileReader("config.json");
    }
}

Tratamiento de Unchecked Exceptions: Programación Defensiva

Al derivar de RuntimeException, el compilador no exige el uso de try-catch ni la declaración con throws. Aunque la sintaxis permite capturarlas, la buena práctica establece que las Unchecked Exceptions no deben enmascararse con try-catch, sino prevenirse mediante validaciones previas (programación defensiva).

// MALA PRÁCTICA: Usar try-catch para tapar un error de lógica del programador
public void mostrarLongitudIncorrecto(String texto) {
    try {
        IO.println("Longitud: " + texto.length()); // Si texto es null, lanza NullPointerException
    } catch (NullPointerException e) {
        IO.println("Error: La cadena recibida era nula.");
    }
}
 
// BUENA PRÁCTICA: Programación defensiva (validación explícita de condiciones)
public void mostrarLongitudCorrecto(String texto) {
    if (texto != null) {
        IO.println("Longitud: " + texto.length());
    } else {
        IO.println("Aviso: No se puede procesar una cadena nula.");
    }
}

Resumen de Estrategias de Tratamiento

Tipo de Excepción Control del Compilador Estrategia Recomendada
Checked Exception Obligatorio Usar try-catch para recuperarse localmente o throws para delegar la gestión a capas superiores.
Unchecked Exception Opcional Evitar su aparición mediante validaciones preliminares (if). Evitar el abuso de try-catch.
En el desarrollo de backend moderno, la mayoría de los frameworks (como Spring Boot) disponen de manejadores globales de excepciones (por ejemplo, mediante la anotación @ControllerAdvice).

Por este motivo, la arquitectura moderna favorece crear excepciones personalizadas que hereden de RuntimeException (Unchecked). De este modo, evitamos llenar las clases de negocio y servicios con bloques try-catch repetitivos o firmas de métodos sobrecargadas con throws. La excepción se interrumpe de forma limpia, vuela hasta el manejador global, y este se encarga automáticamente de capturarla, registrar el log y devolver la respuesta HTTP adecuada (por ejemplo, un código 400 Bad Request o 404 Not Found en formato JSON) al cliente web.

Para capturar y gestionar las excepciones en tiempo de ejecución, Java proporciona una estructura de bloques bien definida.

El bloque clásico: try - catch - finally

  • try: Delimita el bloque de código que contiene operaciones susceptibles de lanzar una excepción. Si ocurre un fallo, la ejecución del bloque se interrumpe inmediatamente en la línea del error.

  • catch: Captura la excepción producida en el bloque try. Se pueden encadenar múltiples bloques catch para gestionar distintos tipos de excepciones de forma específica. Regla de orden: deben colocarse siempre desde la excepción más específica (hija) hasta la más genérica (padre).

  • finally: Bloque de ejecución garantizada. El código dentro de finally se ejecutará siempre, independientemente de si se lanzó una excepción, si esta fue capturada o si el bloque try ejecutó un return. Históricamente se utilizaba para liberar recursos críticos (cerrar ficheros, desconectar bases de datos o liberar sockets).
public class GestionTradicional {
 
    public void leerFicheroClasico() {
        FileReader reader = null;
        try {
            reader = new FileReader("datos.txt");
            int caracter = reader.read();
            IO.println("Primer carácter: " + (char) caracter);
        } catch (IOException e) {
            // Captura de errores de Entrada/Salida
            IO.println("Error al procesar el archivo: " + e.getMessage());
        } finally {
            // Limpieza manual obligatoria: Garantizamos el cierre del recurso
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    IO.println("Error al cerrar el lector.");
                }
            }
            IO.println("Operación finalizada (bloque finally ejecutado).");
        }
    }
}

Simplificación moderna: try-with-resources (Java 7+)

La gestión manual de cierre de recursos en el bloque finally genera un código redundante, propenso a errores y difícil de leer. Para solucionarlo, Java introduce el bloque try-with-resources.

Cualquier clase que implemente la interfaz java.lang.AutoCloseable (o java.io.Closeable) puede instanciarse dentro de los paréntesis del try. Java se encargará de invocar automáticamente su método close() al finalizar el bloque, se haya producido una excepción o no.

Además de capturar las excepciones lanzadas por el propio API de Java, podemos provocar nuestras propias excepciones o crear tipos de error específicos para nuestro dominio de negocio.

Las palabras clave throw y throws

  • throw (Acción): Se utiliza dentro del cuerpo de un método para lanzar explícitamente una instancia de excepción (throw new MiExcepcion(“Detalle…”);). Detiene inmediatamente la ejecución normal del método.

  • throws (Declaración): Se añade en la firma del método para avisar a los invocadores de que este método puede propagar una Checked Exception que no ha sido capturada internamente.

Excepciones Personalizadas

Crear clases de excepción propias permite dar nombres significativos a los fallos de nuestra aplicación (ej. UsuarioNoEncontradoException, SaldoInsuficienteException).

Para crearlas, basta con extender de Exception (si queremos que sea verificada) o de RuntimeException (si queremos que sea no verificada, opción recomendada en arquitectura moderna).

public class ConfigurationException extends RuntimeException {
 
    // Constructor básico con mensaje
    public ConfigurationException(String mensaje) {
        super(mensaje);
    }
 
    // Constructor con mensaje y causa (Exception Chaining)
    // Permite envolver una excepción de bajo nivel dentro de una de nuestro dominio
    public ConfigurationException(String mensaje, Throwable causa) {
        super(mensaje, causa);
    }
}
public void validarClave(String clave) {
    if (clave == null || clave.isEmpty()) {
        // Lanzamiento explícito mediante 'throw'
        throw new ConfigurationException("La clave de configuración no puede estar vacía.");
    }
}
 
public void procesarFichero(String ruta) {
    try {
        FileReader fr = new FileReader(ruta);
    } catch (IOException e) {
        // Encadenamiento de excepciones (Exception Chaining):
        // Capturamos una IOException de bajo nivel y lanzamos nuestra excepción de dominio preservando la causa 'e'
        throw new ConfigurationException("Error al cargar la configuración desde " + ruta, e);
    }
}
Al capturar un error técnico (como un fallo de base de datos o de archivo) y relanzarlo como una excepción propia de negocio, pásale siempre la excepción original como segundo argumento al constructor (super(mensaje, causa);). De este modo, no se perderá la traza original del problema cuando se registre en el archivo de log.

En las aplicaciones web modernas y arquitecturas de microservicios, la lectura de ficheros se centra en la carga de archivos de configuración y el intercambio de datos. Para ello se utilizan formatos estructurados estandarizados: JSON, YAML y XML.

Formato Sintaxis Base Casos de Uso Principales Ventajas
JSON Clave-Valor, Arrays {} [] APIS REST, intercambio de datos web, configs simples Ligero, nativo en la web, fácil parseo
YAML Indentación por espacios Configuración de aplicaciones (Spring Boot, Docker, K8s) Altamente legible por humanos, admite comentarios
XML Etiquetas anidadas <tag></tag> Configuración empresarial (Log4j2, Maven pom.xml), SOAP Validación estricta con esquemas (XSD), estándares robustos

El proceso de convertir un fichero en cualquiera de estos formatos a objetos Java de nuestro dominio se denomina deserialización (y la operación inversa, serialización).

Durante este proceso, es donde ocurren la mayoría de las excepciones de entrada/salida y parseo que la aplicación debe controlar:

  • FileNotFoundException / IOException: El archivo no existe en la ruta indicada, el nombre está mal escrito o el proceso no tiene permisos de lectura.

  • Excepciones de Formato/Sintaxis: El archivo contiene caracteres inválidos, etiquetas sin cerrar (XML) o claves mal formadas.

  • Excepciones de Conversión de Tipos (NumberFormatException): Ocurre cuando la aplicación espera leer un parámetro numérico (ej. un puerto o número de conexiones) pero en el fichero se ha escrito un texto no válido.

Para leer archivos de configuración sin necesidad de librerías externas ni mapeadores complejos, Java proporciona la clase nativa java.util.Properties. Podemos diseñar una clase de utilidad para realizar esta lectura de forma limpia:

public class ConfigurationLoader {
 
    /**
     * Carga un archivo de propiedades y valida sus valores clave.
     * @param filePath Ruta relativa o absoluta del archivo .properties
     * @return Objeto Properties cargado, o null si ocurrió un error crítico
     */
    public Properties loadSettings(String filePath) {
        Properties config = new Properties();
 
        // Uso de try-with-resources para garantizar el cierre del fichero
        try (FileInputStream file = new FileInputStream(filePath)) {
 
            // Carga el contenido del fichero en el objeto Properties
            config.load(file);
 
            // Lectura y conversión explícita con control de errores de tipo
            String url = config.getProperty("db.url");
            int maxConnections = Integer.parseInt(config.getProperty("db.max_connections"));
 
            IO.println("Configuration loaded successfully. Max connections: " + maxConnections);
            return config;
 
        } catch (FileNotFoundException e) {
            IO.println("Critical error: Configuration file not found at " + filePath);
        } catch (IOException e) {
            IO.println("I/O error while reading configuration file: " + e.getMessage());
        } catch (NumberFormatException e) {
            IO.println("Format error: db.max_connections must be a valid integer.");
        }
 
        return null; // Si ocurre cualquier excepción, devolvemos null
    }
}

Esta aproximación facilita la sustitución de componentes y la realización de pruebas unitarias en el futuro:

static void main() {
    // Instanciación del servicio de configuración
    ConfigurationLoader configLoader = new ConfigurationLoader();
 
    // Carga de ajustes desde el fichero
    Properties config = configLoader.loadSettings("config.properties");
 
    if (config != null) {
        // Uso de los valores leídos
        String dbUrl = config.getProperty("db.url");
        IO.println("Connecting to database at: " + dbUrl);
    } else {
        IO.println("Application failed to start due to invalid configuration.");
    }
}
En los temas posteriores aprenderemos a mapear automáticamente archivos JSON y YAML a objetos Java complejos.

Ejercicio 1

Crea un programa que calcule el coste total de una compra a partir del precio unitario en céntimos y el número de unidades, ambos enteros.

Implementa un método que reciba los dos valores y devuelva el producto. Utiliza Math.multiplyExact para detectar un resultado que no quepa en un int. En main, captura ArithmeticException y muestra un mensaje si se produce un desbordamiento.

Prueba:

Precio en céntimos Unidades Resultado esperado
250 3 Total: 750 céntimos
0 10 Total: 0 céntimos
2000000000 2 Mensaje de desbordamiento

Para estas pruebas, los dos valores son no negativos.

Ejercicio 2

Crea un programa que interprete una orden para controlar una luz. El programa recibe una cadena y devuelve el nuevo estado:

  • encender produce encendida.
  • apagar produce apagada.
  • Cualquier otra orden provoca una IllegalArgumentException con un mensaje que indique la orden no reconocida.

Organiza el procesamiento en dos métodos auxiliares: uno recibe la orden y llama al otro, que la comprueba y devuelve el estado. Deja que la excepción se propague hasta main.

En main, muestra el estado o el mensaje de error y utiliza finally para mostrar Orden procesada después de cualquiera de los dos resultados.

Prueba:

Orden Resultado antes de finally
encender Estado: encendida
apagar Estado: apagada
alternar Mensaje de orden no reconocida

Comprueba que Orden procesada aparece al final en los tres casos.

Ejercicio 3

Crea un programa que reciba dos cadenas, las convierta en números enteros y divida el primero entre el segundo mediante división entera.

Captura por separado NumberFormatException y ArithmeticException en main. Muestra un mensaje diferente para cada error; si la operación es válida, muestra el resultado.

Prueba estas entradas:

Primera cadena Segunda cadena Resultado esperado
“12” “3” Resultado: 4
“doce” “3” Mensaje de número no válido
“12” “0” Mensaje de división no válida

Ejercicio 4

Crea un programa con un método que reciba un array de enteros y un índice, y devuelva el elemento solicitado. Antes de acceder al array, comprueba que:

  • La referencia al array no sea null.
  • El índice esté dentro de sus límites.

Si alguna comprobación falla, lanza una RuntimeException o una subclase adecuada, con un mensaje que explique el problema. Captura la excepción en main y muestra su mensaje.

Prueba el método con el array {10, 20, 30}:

Array Índice Resultado esperado
{10, 20, 30} 1 Muestra 20
{10, 20, 30} -1 Mensaje de índice no válido
{10, 20, 30} 3 Mensaje de índice no válido
null 0 Mensaje de array no disponible

Ejercicio 5

En el directorio desde el que ejecutes el programa, crea notas.txt con estas dos líneas:

Primera nota
Segunda nota

Escribe dos variantes de un método que reciba el nombre de un fichero y devuelva una lista con todas sus líneas:

  1. La primera captura la posible IOException dentro del método y devuelve null para indicar que la lectura ha fallado.
  2. La segunda declara IOException con throws y deja que se propague.

Cierra el recurso utilizado para leer. En ambos casos, main muestra las líneas devueltas o, si falla la lectura, muestra un mensaje de error: en la primera variante comprueba el valor devuelto y en la segunda captura la excepción. Explica la diferencia entre las dos estrategias.

Prueba ambas variantes con:

  • notas.txt: deben mostrarse las dos líneas, en orden.
  • no-existe.txt: asegúrate antes de que no existe; debe mostrarse un mensaje de error de lectura.

Ejercicio 6

Crea un programa que reciba dos cadenas y:

  1. Convierta ambas a enteros.
  2. Rechace un primer número negativo lanzando IllegalArgumentException.
  3. Divida el primer número entre el segundo mediante división entera.

En main, utiliza capturas distintas para NumberFormatException, ArithmeticException e IllegalArgumentException. Recuerda que NumberFormatException es una subclase de IllegalArgumentException: su captura debe aparecer antes. Añade un bloque finally que muestre Operación terminada.

Prueba:

Entradas Resultado esperado antes de finally
“12”, “3” Resultado: 4
“doce”, “3” Mensaje de número no válido
“12”, “0” Mensaje de división no válida
“-12”, “3” Mensaje de primer número negativo

En los cuatro casos, comprueba que Operación terminada se muestra después del resultado o del mensaje de error.

Ejercicio 7

Crea dos ficheros de texto en el directorio de ejecución:

correcto.txt:

Uno
Dos

fallo.txt:

Uno
FALLO

Implementa una clase que gestione la lectura de un fichero e implemente AutoCloseable. Cuando lea una línea igual a FALLO, debe lanzar una IOException para simular un fallo reproducible.

Para comprobar el orden de los acontecimientos sin imprimir desde la clase:

  • Comparte con ella una lista de eventos accesible desde main.
  • Cuando close() cierre el lector, añade a la lista Recurso cerrado.
  • En main, dentro de try-with-resources, añade a la lista cada línea leída.
  • Fuera del bloque, captura la excepción en main y añade a la lista un mensaje de error.
  • Después, muestra la lista desde main, en orden.

Prueba ambos ficheros y comprueba estos eventos:

Fichero Eventos esperados, en orden
correcto.txt Uno, Dos, Recurso cerrado
fallo.txt Uno, Recurso cerrado, mensaje de error de lectura

Comprueba que el cierre se produce tanto en la lectura completa como cuando se lanza la excepción.

Ejercicio 8

Crea una excepción propia comprobada llamada SaldoInsuficienteException y un método withdraw que reciba un saldo y una cantidad entera positiva.

El método debe devolver el saldo restante si hay fondos suficientes. Si la cantidad supera el saldo, debe lanzar la excepción con un mensaje que indique el saldo y la cantidad solicitada. Declara la excepción con throws y captúrala en main.

Prueba:

Saldo Cantidad Resultado esperado
100 40 Saldo restante: 60
100 100 Saldo restante: 0
100 120 Mensaje de saldo insuficiente

Para este ejercicio, considera que el saldo no es negativo y que la cantidad solicitada siempre es positiva.

Ejercicio 9

Crea una excepción propia comprobada llamada LecturaDocumentoException. Escribe un método que reciba el nombre de un fichero de texto, lo abra con FileReader y devuelva una lista con sus líneas.

Si se produce una IOException, el método debe lanzar una LecturaDocumentoException con un mensaje que identifique el fichero y conserve la excepción original como causa. Cierra el recurso de lectura.

En main, muestra las líneas devueltas o captura la excepción propia y muestra su mensaje y el tipo de su causa.

Prepara y prueba estos casos:

  • Crea documento.txt con la línea Hola: debe mostrarse esa línea sin error.
  • Asegúrate de que documento-inexistente.txt no existe y solicita su lectura: debe mostrarse el mensaje de la excepción propia y el tipo de la causa original, FileNotFoundException.
  • clase/daw/prog/errores.txt
  • Última modificación: 2026/11/11 12:53
  • por cesguiro