Fundamentos del Manejo de Excepciones en Java

Las excepciones son eventos que interrumpen el flujo normal de un programa. En Java, se utilizan para manejar errores de manera controlada y evitar que el programa termine inesperadamente. Este artículo explica los fundamentos del manejo de excepciones y cómo implementarlo correctamente.

1. ¿Qué son las excepciones?

Una excepción es un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de las instrucciones. En Java, las excepciones son objetos que describen un error o una situación inusual.

2. Jerarquía de excepciones en Java

Todas las excepciones derivan de la clase Throwable. Existen dos categorías principales:

Tipo	Descripción	Ejemplo
Excepciones (Exception)	Errores que pueden ser anticipados y manejados en tiempo de ejecución.	IOException, SQLException
Errores (Error)	Problemas graves del sistema que generalmente no se pueden manejar.	OutOfMemoryError, StackOverflowError

Diferencia entre excepciones comprobadas y no comprobadas

1. Excepciones comprobadas:
   • Son verificadas en tiempo de compilación.
   • El desarrollador debe manejarlas explícitamente o declararlas con throws.
   • Ejemplo: IOException.
2. Excepciones no comprobadas:
   • No requieren manejo explícito en tiempo de compilación.
   • Ejemplo: ArithmeticException.

3. Manejo de excepciones con try-catch

El bloque try-catch se utiliza para manejar excepciones. El código que podría generar una excepción se coloca dentro del bloque try, y el manejo del error en el bloque catch.

Sintaxis:

try {
    // Código que puede generar una excepción
} catch (TipoDeExcepcion e) {
    // Código para manejar la excepción
}

Ejemplo básico:

public class ManejoBasico {
    public static void main(String[] args) {
        try {
            int resultado = 10 / 0; // Genera ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Error: División por cero.");
        }
    }
}

Salida:

Error: División por cero.

4. Uso del bloque finally

El bloque finally contiene código que siempre se ejecuta, independientemente de si ocurre o no una excepción. Es útil para liberar recursos como conexiones a bases de datos o archivos.

Sintaxis:

try {
    // Código que puede generar una excepción
} catch (TipoDeExcepcion e) {
    // Código para manejar la excepción
} finally {
    // Código que siempre se ejecuta
}

Ejemplo práctico:

public class UsoFinally {
    public static void main(String[] args) {
        try {
            int[] numeros = {1, 2, 3};
            System.out.println(numeros[5]); // Genera ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: Índice fuera de rango.");
        } finally {
            System.out.println("Este bloque siempre se ejecuta.");
        }
    }
}

Salida:

Error: Índice fuera de rango.
Este bloque siempre se ejecuta.

5. Lanzar excepciones con throw

El comando throw se utiliza para generar una excepción manualmente.

Sintaxis:

throw new TipoDeExcepcion("Mensaje de error");

Ejemplo:

public class LanzarExcepcion {
    public static void main(String[] args) {
        try {
            validarEdad(15);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void validarEdad(int edad) {
        if (edad < 18) {
            throw new IllegalArgumentException("La edad debe ser mayor o igual a 18.");
        }
    }
}

Salida:

Error: La edad debe ser mayor o igual a 18.

6. Declarar excepciones con throws

El modificador throws indica que un método puede generar ciertas excepciones. Esto delega el manejo de la excepción al código que llama al método.

Sintaxis:

public void metodo() throws TipoDeExcepcion {
    // Código que puede generar una excepción
}

Ejemplo práctico:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class UsoThrows {
    public static void main(String[] args) {
        try {
            leerArchivo("archivo_inexistente.txt");
        } catch (FileNotFoundException e) {
            System.out.println("Error: Archivo no encontrado.");
        }
    }

    public static void leerArchivo(String nombreArchivo) throws FileNotFoundException {
        File archivo = new File(nombreArchivo);
        Scanner lector = new Scanner(archivo); // Puede generar FileNotFoundException
    }
}

Salida:

Error: Archivo no encontrado.

7. Excepciones personalizadas

Puedes crear tus propias excepciones extendiendo la clase Exception o RuntimeException.

Ejemplo de excepción personalizada:

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

public class Principal {
    public static void main(String[] args) {
        try {
            lanzarMiExcepcion();
        } catch (MiExcepcion e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void lanzarMiExcepcion() throws MiExcepcion {
        throw new MiExcepcion("Esto es un error personalizado.");
    }
}

Salida:

Error: Esto es un error personalizado.

8. Errores comunes al manejar excepciones

1. Capturar excepciones genéricas:
   Evita usar catch (Exception e) si puedes manejar excepciones específicas.
2. No liberar recursos:
   Usa bloques finally o try-with-resources para cerrar recursos como archivos o conexiones.
3. Abusar de excepciones comprobadas:
   Usa excepciones comprobadas solo cuando sea necesario, para evitar un código demasiado cargado.

Resumen

• Las excepciones permiten manejar errores en tiempo de ejecución de manera controlada.
• Usa try-catch para capturar y manejar excepciones.
• El bloque finally asegura que ciertas tareas se ejecuten siempre.
• Usa throw y throws para generar y declarar excepciones.
• Crea excepciones personalizadas para modelar errores específicos de tu aplicación.