Dominando las Excepciones en Java: Manejo Elegante de Errores Inesperados

Una excepción es un problema que surge durante la ejecución de un programa, interrumpiendo su flujo normal. Si no se maneja, la aplicación termina abruptamente. Java proporciona un mecanismo robusto para capturar y gestionar estas situaciones.

Categorías de Excepciones

1. Excepciones Verificadas (Checked Exceptions)

El compilador obliga a manejarlas (try-catch o throws). Ocurren en tiempo de compilación. Ejemplos: IOException, FileNotFoundException, SQLException.

Ejemplo

import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {
    public static void main(String args[]) {
        File file = new File("E://file.txt");
        FileReader fr = new FileReader(file); // Error de compilación si no se maneja
    }
}

Error del compilador: unreported exception FileNotFoundException; must be caught or declared to be thrown

2. Excepciones No Verificadas (Unchecked / Runtime Exceptions)

Ocurren en tiempo de ejecución. Son errores de programación (lógica, uso incorrecto de API). El compilador no obliga a manejarlas. Ejemplos: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

Ejemplo

public class Unchecked_Demo {
    public static void main(String args[]) {
        int num[] = {1, 2, 3, 4};
        System.out.println(num[5]); // ArrayIndexOutOfBoundsException
    }
}

3. Errores (Errors)

Problemas graves fuera del control del programador (ej. OutOfMemoryError, StackOverflowError). No se deben capturar normalmente.

Jerarquía de Excepciones

Todas las excepciones heredan de java.lang.Exception, que a su vez hereda de Throwable. La otra rama de Throwable es Error.

Throwable
 ├── Error (fallos graves del JVM)
 └── Exception
      ├── IOException (y subclases: checked)
      └── RuntimeException (y subclases: unchecked)

Métodos Importantes de Throwable

Método	Descripción
getMessage()	Mensaje detallado de la excepción
getCause()	Causa raíz (objeto Throwable)
toString()	Nombre de clase + mensaje
printStackTrace()	Imprime traza completa en System.err
getStackTrace()	Array de elementos de la pila de llamadas
fillInStackTrace()	Rellena la traza de pila actual

Captura de Excepciones: try-catch

try {
    // código protegido (puede lanzar excepción)
} catch (TipoExcepcion e) {
    // manejo de la excepción
}

Ejemplo Básico

public class ExcepTest {
    public static void main(String args[]) {
        try {
            int a[] = new int[2];
            System.out.println("Acceso al elemento 3: " + a[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Excepción capturada: " + e);
        }
        System.out.println("Fuera del bloque try-catch");
    }
}

Salida:

Excepción capturada: java.lang.ArrayIndexOutOfBoundsException: 3
Fuera del bloque try-catch

Múltiples Bloques catch

Se evalúan en orden; el primero que coincida con el tipo de excepción la maneja.

try {
    // código riesgoso
} catch (FileNotFoundException e) {
    // manejo específico
} catch (IOException e) {
    // manejo genérico de I/O
} catch (Exception e) {
    // captura cualquier otra excepción
}

Captura Múltiple en un Solo catch (Java 7+)

catch (IOException | FileNotFoundException ex) {
    logger.log(ex);
    throw ex;
}

Palabras Clave throws y throw

• throws: En la firma del método, declara que puede lanzar excepciones verificadas (delega el manejo al llamador).
• throw: Lanza explícitamente una instancia de excepción.

Ejemplo

public void withdraw(double amount) throws RemoteException, InsufficientFundsException {
    if (amount <= balance) {
        balance -= amount;
    } else {
        double needs = amount - balance;
        throw new InsufficientFundsException(needs); // throw explícito
    }
}

Bloque finally

Siempre se ejecuta, haya o no excepción. Ideal para limpieza (cerrar recursos).

try {
    // código protegido
} catch (Exception e) {
    // manejo
} finally {
    // limpieza: cerrar archivos, conexiones, etc.
}

Ejemplo

public class ExcepTest {
    public static void main(String args[]) {
        int a[] = new int[2];
        try {
            System.out.println("Acceso elemento 3: " + a[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Excepción: " + e);
        } finally {
            a[0] = 6;
            System.out.println("Primer elemento: " + a[0]);
            System.out.println("Bloque finally ejecutado");
        }
    }
}

try-with-resources (Java 7+) — Gestión Automática de Recursos

Los recursos que implementan AutoCloseable se cierran automáticamente al salir del bloque try.

Sintaxis

try (FileReader fr = new FileReader("archivo.txt")) {
    // usar el recurso
} catch (IOException e) {
    e.printStackTrace();
}
// fr.close() se llama automáticamente

Reglas Clave

• La clase debe implementar AutoCloseable.
• Puede declararse más de un recurso (se cierran en orden inverso).
• Los recursos declarados son implícitamente final.

Excepciones Personalizadas (User-Defined Exceptions)

Para crear una excepción propia:

1. Extiende Exception (checked) o RuntimeException (unchecked).
2. Añade campos y métodos útiles.

Ejemplo: InsufficientFundsException

public class InsufficientFundsException extends Exception {
    private double amount;

    public InsufficientFundsException(double amount) {
        this.amount = amount;
    }

    public double getAmount() {
        return amount;
    }
}

Uso en CheckingAccount

public class CheckingAccount {
    private double balance;
    private int number;

    public CheckingAccount(int number) { this.number = number; }

    public void deposit(double amount) { balance += amount; }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount <= balance) {
            balance -= amount;
        } else {
            double needs = amount - balance;
            throw new InsufficientFundsException(needs);
        }
    }
    // getters...
}

Demostración

public class BankDemo {
    public static void main(String[] args) {
        CheckingAccount c = new CheckingAccount(101);
        c.deposit(500.00);
        try {
            c.withdraw(100.00);
            c.withdraw(600.00); // lanza excepción
        } catch (InsufficientFundsException e) {
            System.out.println("Faltan $" + e.getAmount());
            e.printStackTrace();
        }
    }
}

Salida:

Depositing $500...
Withdrawing $100...
Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException at CheckingAccount.withdraw(...)

Excepciones Comunes

• Excepciones del JVM: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.
• Excepciones Programáticas: IllegalArgumentException, IllegalStateException.