Excepciones en Java

Tabla de Contenidos

Definición

Las excepciones en Java son eventos imprevistos que pueden ocurrir durante la ejecución de un programa, el cual termina de forma abrupta.

Tipos

Se pueden clasificar en dos categorías principales:

Excepciones comprobadas (checked): son aquellas son detectadas en tiempo de compilación. Normalmente, se exige que una función que incluye este tipo de excepción utilice throws.
Excepciones no comprobadas (unchecked): son detectadas en tiempo de ejecución.

Bloque try-catch

La estructura básica involucra un bloque try que rodea el código propenso a excepciones y uno o varios bloques catch para manejar excepciones específicas.

Esto permite a los programadores capturar y gestionar las excepciones de manera controlada.

Bloque finally

El bloque finally es esencial para liberar recursos o realizar tareas de limpieza necesarias, como cierre de archivos o conexiones a bases de datos. Este bloque se ejecuta siempre, incluso si no se produce ninguna excepción.

Ahora tenemos un ejemplo que conforma todos los bloques.

import java.util.Scanner;
import java.util.InputMismatchException;

public class EjemploTryCatchFinallyScanner {
    public static void main(String[] args) {
        Scanner scanner = null;

        try {
            scanner = new Scanner(System.in);
            System.out.print("Por favor, ingresa un número entero: ");
            int primero = scanner.nextInt();
            int segundo = scanner.nextInt();
            System.out.println("Division: " + (primero / segundo));
        } catch (InputMismatchException e) {
            System.out.println("Error: No ingresaste un número entero válido.");
        } catch (ArithmeticException e) {
            System.out.println("Error: Se produjo una excepción aritmética.");
        } catch (Exception e) {
            System.out.println("Error general: " + e.getMessage());
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }
    }
}

Cabe señalar que se tienen varios bloques de catch en donde se establece cada posible excepción que esté involucrada.

Sin embargo, el orden es importante. Se deja justo al final el bloque Exception, esto debido a que al ser una excepción base, absorbe todas las excepciones que no estén definidas en los bloques previos. Por ello se deja al final.

Throw

En Java, es posible lanzar excepciones manualmente empleando la palabra clave throw. Esto es útil cuando se desea señalar un problema específico en el código.

public class Cuenta {
    private double saldo;

    public Cuenta(double saldoInicial) {
        if (saldoInicial < 0) {
            throw new IllegalArgumentException("El saldo inicial no puede ser negativo");
        }
        this.saldo = saldoInicial;
    }

    public void depositar(double monto) {
        if (monto < 0) {
            throw new IllegalArgumentException("No se puede depositar un monto negativo");
        }
        saldo += monto;
    }

    public static void main(String[] args) {
        Cuenta miCuenta = new Cuenta(100.0);

        try {
            miCuenta.depositar(50.0);
            miCuenta.depositar(-10.0); // Intento de depósito negativo
        } catch (IllegalArgumentException e) {
            System.out.println("Excepción atrapada: " + e.getMessage());
        }

        System.out.println("Saldo actual: " + miCuenta.saldo);
    }
}

En el ejemplo anterior, se usa throw para lanzar excepciones que normalmente no lo serían, pero se vinculan a las reglas de negocio de cómo funciona una cuenta: evitar depósitos negativos.

Ejemplos

En el siguiente ejemplo usamos el manejo de excepciones para evitar que el menú genere una excepción.

import java.util.InputMismatchException;
import java.util.Scanner;

public class MenuConsola {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean continuar = true;

        while (continuar) {
            System.out.println("Menú:");
            System.out.println("1. Opción 1");
            System.out.println("2. Opción 2");
            System.out.println("3. Salir");

            try {
                System.out.print("Elige una opción: ");
                int opcion = scanner.nextInt();

                switch (opcion) {
                    case 1:
                        System.out.println("Seleccionaste la Opción 1");
                        break;
                    case 2:
                        System.out.println("Seleccionaste la Opción 2");
                        break;
                    case 3:
                        continuar = false;
                        System.out.println("Saliendo del programa.");
                        break;
                    default:
                        System.out.println("Opción no válida. Por favor, elige una opción válida (1, 2 o 3).");
                }
            } catch (InputMismatchException e) {
                System.out.println("Error: Debes ingresar un número entero válido.");
                scanner.next(); // Limpiar el búfer del scanner
            }
        }

        scanner.close();
    }
}