Una excepción es un evento inesperado que ocurre durante la ejecución de un programa, provocando una interrupción en el flujo normal. Si no se maneja adecuadamente, puede llevar a la terminación abrupta de la JVM.

Tipos de excepciones

Excepciones verificadas (en tiempo de compilación)

import java.text.SimpleDateFormat;
import java.util.Date;

public class FechaParser {
    public static void main(String[] args) {
        SimpleDateFormat formato = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date fecha = formato.parse("2022-11-07");
            System.out.println("Fecha parseada: " + fecha);
        } catch (Exception e) {
            System.err.println("Error al procesar la fecha: " + e.getMessage());
        }
    }
}

Excepciones no verificadas (en tiempo de ejecución)

public class ValidadorParametros {
    public static void main(String[] args) {
        validarEntrada(null);
    }

    public static void validarEntrada(String entrada) {
        if (entrada == null || entrada.trim().isEmpty()) {
            throw new IllegalArgumentException("El parámetro no puede estar vacío");
        }
        System.out.println("Valor válido: " + entrada);
    }
}

Mecanismo de manejo por defecto de la JVM

• Si el código actual tiene un bloque catch, la excepción se maneja y la ejecución continúa.
• Si no hay manejo, la excepción se propaga hasta la JVM, que imprime el stack trace y finaliza el programa.

Estrategias de manejo de excepciones

Declaración con throws

public void procesarCadena(String texto) throws IllegalArgumentException {
    if (texto == null) {
        throw new IllegalArgumentException("Texto nulo no permitido");
    }
    System.out.println(texto.length());
}

Captura con try-catch

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ProcesadorFecha {
    private static final Logger log = LoggerFactory.getLogger(ProcesadorFecha.class);

    public static void main(String[] args) {
        String fechaStr = "2025/10/01";
        try {
            Date resultado = convertirFecha(fechaStr);
            System.out.println("Fecha convertida: " + resultado);
        } catch (Exception ex) {
            System.out.println("Se capturó una excepción");
            log.error("Error en conversión: {}", ex.getMessage());
        }
    }

    private static Date convertirFecha(String entrada) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.parse(entrada);
    }
}

Diferencia entre throws y throw

• throws: Se declara en la firma del método para indicar qué excepciones puede lanzar.
• throw: Se usa dentro del cuerpo del método para lanzar manualmente una excepción específica.

Jerarquía de clases de excepciones

• Throwable: Clase base de todas las excepciones y errores.
• Error: Problemas graves que no deben manejarse (ej. OutOfMemoryError).
• Exception: Excepciones recuperables.
  • Verificadas: Requieren manejo explícito.
  • No verificadas (RuntimeException): Opcionales de manejar.

Métodos útiles de Throwable

e.getMessage()     // Mensaje descriptivo
e.toString()       // Representación textual corta
e.printStackTrace() // Imprime traza completa en consola

Excecpiones personalizadas

public class RangoEdadInvalido extends RuntimeException {
    public RangoEdadInvalido() {
        super("La edad debe estar entre 18 y 50 años");
    }

    public RangoEdadInvalido(String detalle) {
        super(detalle);
    }
}

// Uso:
if (edad < 18 || edad > 50) {
    throw new RangoEdadInvalido("Edad recibida: " + edad);
}

Prácticas recomendadas

• Usa throws en métodos interons para delegar el manejo.
• Usa try-catch en el método main o en puntos estratégicos de la aplicación.
• Ordena los bloques catch de más específico a más general.
• Registra excepciones en logs para diagnóstico posterior.
• Crea excepciones personalizadas para mejorar la legibilidad y el mantenimiento.