0x3 - Manejo de Excepciones

try {
    procesarArchivo();
} catch (IOException e) {
    // Solo loggear y relanzar
    logger.error("Error: " + e.getMessage());
    throw e;  // ❌ No agrega valor
}

// ✅ Dejar propagar - agregar throws en firma
public void procesar() throws IOException {
    procesarArchivo();  // Propaga naturalmente
}

public static void main(String[] args) throws Exception {  // ❌
    // código
}

public static void main(String[] args) {
    try {
        ejecutarPrograma();
    } catch (IOException e) {
        System.err.println("Error de archivo: " + e.getMessage());
        System.exit(1);
    }
}

/**
 * Excepciones del dominio de Facturación.
 * <p>
 * Se usan excepciones UNCHECKED porque:
 * - Los errores son de programación (precondiciones violadas)
 * - No se espera recuperación en tiempo de ejecución
 */
package ar.unrn.facturacion.excepciones;

try {
    if (invalido) {
        throw new IllegalArgumentException();
    }
} catch (IllegalArgumentException e) {
    // manejar
}

if (invalido) {
    // manejar directamente
} else {
    // flujo normal
}

try {
    leerArchivo();
} catch (IOException e) {
    throw new RuntimeException("Error");  // ❌ Pérdida de información
}

try {
    leerArchivo();
} catch (IOException e) {
    throw new ArchivoNoDisponibleException("No se pudo leer: " + archivo, e);
}

try {
    // código
} catch (Exception e) {  // ❌ Demasiado genérico
    // manejar
}

try {
    // código
} catch (IOException e) {
    // manejar IO
} catch (SQLException e) {
    // manejar BD
}

if (arreglo == null || arreglo.length == 0) {
    throw new IllegalArgumentException("Arreglo inválido");
}

if (arreglo == null) {
    throw new NullPointerException("El arreglo no puede ser null");
}
if (arreglo.length == 0) {
    throw new IllegalArgumentException("El arreglo no puede estar vacío");
}

/**
 * Verifica que un arreglo no sea null ni esté vacío.
 * @param arreglo el arreglo a verificar
 * @throws NullPointerException si el arreglo es null
 * @throws IllegalArgumentException si el arreglo está vacío
 */
private static void validarArreglo(int[] arreglo) {
    if (arreglo == null) {
        throw new NullPointerException("El arreglo no puede ser null");
    }
    if (arreglo.length == 0) {
        throw new IllegalArgumentException("El arreglo no puede estar vacío");
    }
}

public void metodo() throws RuntimeException {  // ❌ Innecesario
    // código
}

public void metodo() {  // ✅ RuntimeException no se declara
    // código
}

throw new Exception("error");
throw new RuntimeException("error");

throw new MiExcepcionEspecifica("error");
throw new IllegalArgumentException("parámetro inválido");

try {
    int resultado = dividir(a, b);
} catch (ArithmeticException e) {
    // manejar división por cero
}

if (b != 0) {
    int resultado = dividir(a, b);
} else {
    // manejar caso especial
}

try {
    operacionRiesgosa();
} catch (Exception e) {
    // ❌ Bloque vacío - se silencia el error
}

try {
    operacionRiesgosa();
} catch (Exception e) {
    logger.error("Error en operación riesgosa", e);
    // Y tomar decisión: reintentar, valor por defecto, etc.
}

try {
    leerArchivo();
} catch (IOException e) {
    throw new IOException(e);  // ❌ Solo envuelve, no agrega valor
}

try {
    leerArchivo();
} catch (IOException e) {
    throw new ArchivoConfiguracionException(
        "No se pudo leer configuración de: " + archivo, e);
}

try {
    operacion();
} catch (Exception e) {
    e.printStackTrace();  // ❌ Solo imprime, no maneja
}

try {
    operacion();
} catch (OperacionException e) {
    logger.error("Error en operación", e);
    // Reintentar, usar valor por defecto, o relanzar
}