1. Diferenciación entre Error y Exception

En el ecosistema Java, es fundamental distinguir entre Error y Exception para una gestión robusta del programa.

• Un Error representa problemas graves que la aplicación no puede ni debe intentar manejar. Son situaciones críticas que generalmente escapan al control del programador y a menudo son indicativas de fallos a nivel de la Máquina Virtual de Java (JVM) o del sistema. Ejemplos comunes incluyen OutOfMemoryError, StackOverflowError o ThreadDeath. Cuando ocurre un Error, la JVM suele terminar el hilo de ejecución correspondiente, ya que son considerados fallos fatales e irrecuperables.
• Una Exception, por otro lado, denota condiciones excepcionales que un programa Java puede y debe gestionar. Estas situaciones, aunque inesperadas, pueden ser capturadas y procesadas por la lógica de la aplicación, permitiendo una recuperación o una terminación controlada. Las excepciones se dividen en dos categorías principales: excepcionse en tiempo de ejecución (runtime exceptions) y excepciones verificadas (checked exceptions).

2. Clasificación de Excepciones: Runtime vs. Verificadas

Las excepciones se categorizan en función de si el compilador de Java exige su manejo explícito:

• Las excepciones en tiempo de ejecución (Runtime Exceptions), también conocidas como excepciones no verificadas (Unchecked Exceptions), son subclases de java.lang.RuntimeException. El compilador de Java no fuerza a los desarrolladores a manejar o declarar estas excepciones. Generalmente, son el resultado de errores de lógica en el código, como NullPointerException (intento de acceder a un objeto nulo) o IndexOutOfBoundsException (intento de acceder a un índice fuera de los límites de un arreglo). Aunque no son obligatorias de manejar, es una buena práctica corregir la lógica que las causa.
• Las excepciones verificadas (Checked Exceptions) son todas aquellas que no son subclases de RuntimeException. El compilador de Java exige explícitamente que estas excepciones sean manejadas (con un bloque try-catch) o declaradas (con la cláusula throws en la firma del método). Si no se hace, el programa no compilará. Ejemplos incluyen IOException, SQLException o ClassNotFoundException. Estas excepciones suelen ser causadas por factores externos al programa, como la disponibilidad de un archivo o una conexión de red.

3. Excepciones Comunes Integradas en Java

Java ofrece una amplia gama de clases de excepción predefinidas para cubrir diversos escenarios:

Excepciones no verificadas (Unchecked Exceptions):

Excepciones verificadas (Checked Exceptions):

4. Métodos Fundamentales de la Clase Throwable

Todos los objetos de excepción y error en Java heredan de la clase java.lang.Throwable, que proporciona varios métodos útiles para obtener información sobre la excepción:

• public String getMessage(): Devuelve un mensaje detalado sobre la excepción que ocurrió. Este mensaje se inicializa típicamente en el constructor de la clase Throwable.
• public String toString(): Retorna una breve descripción del objeto Throwable, incluyendo su clase y el mensaje devuelto por getMessage().
• public void printStackTrace(): Imprime este Throwable y su rastreo de pila al flujo de error estándar, lo que es útil para depurar.
• public StackTraceElement[] getStackTrace(): Proporciona un arreglo de elementos del rastreo de pila, lo que permite un análisis programático de la pila de llamadas. El elemento en el índice 0 representa la parte superior de la pila.
• public Throwable getCause(): Devuelve la causa de esta excepción o null si la causa es desconocida o inexistente.

5. Captura y Manejo de Excepciones (try-catch-finally)

El mecanismo try-catch-finally es la forma estándar de manejar excepciones en Java, permitiendo un flujo de control estructurado.

• El bloque try encierra el código que podría lanzar una excepción.
• El bloque catch se utiliza para capturar y manejar un tipo específico de excepción. Pueden existir múltiples bloques catch para manejar diferentes tipos de excepciones.
• El bloque finally contiene código que se ejecutará siempre, independientemente de si se lanzó o no una excepción en el bloque try, o si se capturó. Es ideal para tareas de limpieza, como cerrar recursos.

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

public class GestorOperaciones {

    private static void realizarDivisionEnArreglo() {
        int[] misNumeros = {10, 20, 30, 40, 50}; // Array de 5 elementos
        Scanner lectorEntrada = new Scanner(System.in);

        try {
            System.out.print("Ingrese un índice (0-4): ");
            int indice = lectorEntrada.nextInt();

            System.out.print("Ingrese un divisor (distinto de 0): ");
            int divisor = lectorEntrada.nextInt();

            int resultado = misNumeros[indice] / divisor;
            System.out.println("El resultado de la división es: " + resultado);

        } catch (ArithmeticException e) {
            System.err.println("¡Error: Intento de división por cero!");
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("¡Error: Índice de arreglo fuera de los límites permitidos!");
            e.printStackTrace();
        } catch (InputMismatchException e) {
            System.err.println("¡Error: Entrada inválida. Por favor, ingrese un número entero!");
            e.printStackTrace();
        } finally {
            System.out.println("--- Bloque finally: Operación de arreglo finalizada ---");
            System.out.print("Contenido actual del arreglo: ");
            for (int num : misNumeros) {
                System.out.print(num + " ");
            }
            System.out.println();
            lectorEntrada.close(); // Cerrar el scanner
        }
    }

    public static void main(String[] args) {
        realizarDivisionEnArreglo();
    }
}

6. Lanzamiento de Excepciones (throw y throws)

Java permite al programador lanzar excepciones explícitamente y declarar qué excepciones puede lanzar un método.

• La palabra clave throw se utiliza dentro del cuerpo de un método para lanzar una instancia de una excepción. Es seguida por una instancia de la clase Throwable.
• La palabra clave throws se utiliza en la firma de un método para declarar las excepciones verificadas que el método podría lanzar. Esto informa al compilador y a los invocadores del método que deben manejar esas excepciones.

import java.io.FileNotFoundException; // Una excepción verificada
import java.util.Scanner;

public class ProcesadorDatos {

    // Este método declara que puede lanzar FileNotFoundException
    private static void procesarArchivo(String nombreArchivo) throws FileNotFoundException, IllegalAccessException {
        if (nombreArchivo == null || nombreArchivo.isEmpty()) {
            throw new IllegalArgumentException("El nombre del archivo no puede ser nulo o vacío."); // Excepción no verificada
        }

        if (!nombreArchivo.endsWith(".txt")) {
            throw new IllegalAccessException("Solo se permiten archivos de texto (.txt)."); // Excepción verificada personalizada
        }

        if (!"datos.txt".equals(nombreArchivo)) {
            throw new FileNotFoundException("¡El archivo '" + nombreArchivo + "' no pudo ser encontrado!"); // Excepción verificada
        }

        System.out.println("Archivo '" + nombreArchivo + "' procesado con éxito.");
        // Simulación de operaciones de archivo...
    }

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        System.out.print("Ingrese el nombre del archivo a procesar: ");
        String nombreArchivoUsuario = entrada.nextLine();

        try {
            procesarArchivo(nombreArchivoUsuario);
        } catch (FileNotFoundException e) {
            System.err.println("Error de archivo: " + e.getMessage());
            e.printStackTrace();
        } catch (IllegalAccessException e) { // Captura la excepción personalizada lanzada
            System.err.println("Error de acceso: " + e.getMessage());
            e.printStackTrace();
        } catch (IllegalArgumentException e) { // Captura la excepción no verificada
            System.err.println("Error de argumento: " + e.getMessage());
            e.printStackTrace();
        } finally {
            entrada.close();
        }
    }
}

7. Bloque try-with-resources

Introducido en JDK 7, el try-with-resources es una construcción que garantiza que cada recurso declarado en su bloque try sea cerrado automáticamente al finalizar la ejecución del bloque, sin importar si hubo excepciones o no. Esto es aplicable a cualquier objeto que implemente la interfaz java.lang.AutoCloseable.

import java.io.*;

public class LectorEscritorArchivos {

    public static void main(String[] args) {
        String linea;
        try (
                // Declaración e inicialización de recursos que implementan AutoCloseable
                BufferedReader lector = new BufferedReader(new FileReader("configuracion.txt"));
                BufferedWriter escritor = new BufferedWriter(new FileWriter("log_procesado.txt"))
        ) {
            System.out.println("Iniciando lectura y escritura de archivos...");
            while ((linea = lector.readLine()) != null) {
                System.out.println("Línea leída: " + linea);
                escritor.write("[PROCESADO] " + linea + "\n");
            }
            escritor.flush(); // Asegurar que todo se escriba al archivo
            System.out.println("Proceso de archivos completado exitosamente.");
        } catch (IOException e) {
            // Manejo de cualquier excepción de E/S que pueda ocurrir durante la operación
            // o durante el cierre automático de los recursos
            System.err.println("Ocurrió un error de entrada/salida: " + e.getMessage());
            e.printStackTrace();
        }
    }
}