1. Concepto de Excepción

Las excepciones son condiciones inesperadas que surgen en tiempo de ejecución. La gestión de excepciones es esencial para desarrollar software robusto, ya que permite al programa responder de manera controlada a situaciones imprevistas, evitando fallos graves.

2. Clasificación de Excepciones

Todas las excepciones en Java heredan de la clase Throwable, ubicada en el paquete java.lang. Esta se divide en dos ramas principales:

• Error: Problemas graves del entorno o del sistema, como StackOverflowError o OutOfMemoryError, que generalmente no se pueden recuperar mediante código.
• Exception: Condiciones que pueden ser manejadas por el programador. Se subdividen en:
  • RuntimeException: Excepciones no verificadas (como NullPointerException o ArrayIndexOutOfBoundsException), cuyo manejo es ocpional.
  • CheckedException: Excepciones verificadas (como IOException), que deben ser capturadas o declaradas obligatoriamente.

3. Origen de las Excepciones

Las excepciones se generan automáticamente por la JVM cuando el código viola las reglas del lenguaje o del entorno. Además, el programador puede lanzarlas manualmente usando la palabra clave throw.

Cuando ocurre una excepción, se propaga hacia arriba en la pila de llamadas. Si ningún método la captura, finalmente la JVM la maneja por defecto, mostrando un rastreo de pila y finalizando el programa.

5. Gestión de Excepciones

Java proporciona un mecanismo estructurado para manejar excepciones, basado en cinco palabras clave: try, catch, finally, throw y throws.

(1) Bloque try-catch

Se utiliza para capturar y tratar excepciones específicas. Ejemplo modificado:

import java.util.Scanner;

public class EjemploDivision {
    public static void main(String[] args) {
        Scanner lector = new Scanner(System.in);
        int cociente = 0;
        try {
            System.out.print("Ingresar dividendo: ");
            int dividendo = Integer.parseInt(lector.nextLine());
            System.out.print("Ingresar divisor: ");
            int divisor = Integer.parseInt(lector.nextLine());
            cociente = dividendo / divisor;
        } catch (NumberFormatException errorFormato) {
            System.out.println("Error: entrada no numérica. Detalle: " + errorFormato.getMessage());
        } catch (ArithmeticException errorAritmetico) {
            System.out.println("Error: división por cero.");
        }
        System.out.println("Resultado calculado: " + cociente);
        lector.close();
    }
}

(2) Bloque try-catch-finally

El bloque finally se ejecuta siempre, ocurra o no una excepción, ideal para liberar recursos.

try {
    // Código potencialmente problemático
} catch (Exception tipoExcepcion) {
    // Lógica para manejar la excepción
} finally {
    // Limpieza obligatoria, como cerrar conexiones
}

(3) Múltiples bloques catch

Permiten manejar diferentes tipos de excepciones por separado. Las excepciones más específicas deben colocarse primero.

try {
    // Operación susceptible a excepciones
} catch (FileNotFoundException errorArchivo) {
    // Manejo para archivo no encontrado
} catch (IOException errorIO) {
    // Manejo para errores de E/S
} catch (Exception errorGeneral) {
    // Manejo genérico
}

(4) Bloque try-finally

Se usa cuando solo se necesita garantizar la ejecución de código de limpieza, sin capturar la excepción en ese nivel.

try {
    // Acción que podría fallar
} finally {
    // Tareas de liberación, la excepción se propaga
}

(5) Declaración de excepciones con throws

Cuando un método no maneja una excepción, debe declararla con throws para notificar a los llamadores.

(6) Lanzamiento manual de excepciones con throw

Se puede lanzar una excepción explícita en condiciones personalizadas, por ejemplo: throw new IllegalArgumentException("Valor inválido");

6. Excepciones Personalizadas

Se pueden crear clases de excepción propias extendiendo Exception o RuntimeException. Es común incluir constructores con mensaje para mejorar la depuración.

public class MiExcepcion extends RuntimeException {
    public MiExcepcion(String mensaje) {
        super(mensaje);
    }
}

7. Sobrescritura de Métodos con Excepciones

Al sobrescribir métodos, las reglas para excepciones verificadas son estrictas:

• El método sobrescrito no puede lanzar excepciones verificadas más amplias que las declaradas en el método padre.
• Puede omitir excepciones o lanzar excepciones más específicas.