Jerarquía de excepciones

En Java, las excepciones son eventos que alteran el flujo normal de la ejecución de un programa debido a errores o situaciones inesperadas. Java tiene un robusto sistema de manejo de excepciones basado en clases, donde cada tipo de excepción es una subclase de Throwable. A continuación, te explico la jerarquía de excepciones en Java, sus categorías principales y cómo se gestionan.

Jerarquía de Excepciones en Java

La jerarquía de excepciones de Java se basa en la clase Throwable, que es la raíz de todas las excepciones y errores en Java. La jerarquía se divide en dos grandes categorías: Excepciones (Exceptions) y Errores (Errors).

---

1. Throwable

• Throwable es la clase raíz de todas las excepciones y errores en Java. Hereda de la clase Object, y cualquier clase que desee ser lanzada o capturada como una excepción debe ser una subclase de Throwable.

  
  public class Throwable extends Object {
      // Métodos de Throwable
  }

• Subclases de Throwable:

  • Error
  • Exception

---

2. Error

La clase Error representa problemas graves que normalmente no pueden ser manejados por el código del programa. Estos errores son situaciones que no deberían ser capturadas o gestionadas por el programa, ya que normalmente indican fallos en la máquina virtual de Java (JVM) o en el entorno de ejecución.

• Ejemplos de Error:
  • OutOfMemoryError: Cuando no hay suficiente memoria.
  • StackOverflowError: Cuando se produce un desbordamiento de la pila.
  • VirtualMachineError: Errores graves en la JVM.

Ejemplo de un error:

public class ErrorExample {
    public static void main(String[] args) {
        // Esto generaría un StackOverflowError
        main(args);
    }
}

En general, los errores no deberían ser capturados ni tratados, ya que indican problemas de infraestructura que requieren intervención externa (no son errores lógicos en el código).

---

3. Exception

La clase Exception es la base para las excepciones que pueden ser gestionadas por el programa. A diferencia de los Errors, las excepciones pueden ser atrapadas y manejadas utilizando bloques try-catch. Las excepciones se dividen en dos grandes categorías:

1. Excepciones verificadas (Checked Exceptions)
2. Excepciones no verificadas (Unchecked Exceptions)

---

Excepciones Verificadas (Checked Exceptions)

Las excepciones verificadas son aquellas que el compilador obliga a manejar explícitamente. Esto significa que el código que las genera debe ser rodeado por un bloque try-catch o debe declarar que lanza la excepción mediante throws. Las excepciones verificadas suelen representar situaciones que podrían preverse y manejarse, como errores de E/S, problemas con bases de datos, etc.

Ejemplos de excepciones verificadas:

• IOException: Problemas de entrada/salida (lectura y escritura de archivos).
• SQLException: Errores relacionados con las bases de datos.
• ClassNotFoundException: Clase no encontrada.
• FileNotFoundException: Cuando un archivo no se encuentra.

Ejemplo de manejo de una excepción verificada:

import java.io.*;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            // Intentar abrir un archivo que no existe
            FileReader file = new FileReader("archivo_no_existente.txt");
        } catch (IOException e) {
            System.out.println("Error de entrada/salida: " + e.getMessage());
        }
    }
}

---

Excepciones No Verificadas (Unchecked Exceptions)

Las excepciones no verificadas, también conocidas como errores de tiempo de ejecución, son subclases de RuntimeException. El compilador no obliga a manejar estas excepciones, y generalmente indican errores en la lógica del programa (como un índice fuera de rango, división por cero, etc.). Aunque se pueden manejar, el manejo no es obligatorio.

Ejemplos de excepciones no verificadas:

• NullPointerException: Se lanza cuando se intenta acceder a un objeto null.
• ArrayIndexOutOfBoundsException: Se lanza cuando se accede a un índice fuera de los límites de un array.
• ArithmeticException: Se lanza cuando ocurre una operación ilegal, como la división por cero.
• IllegalArgumentException: Se lanza cuando un método recibe un argumento no válido.

Ejemplo de una excepción no verificada:

public class UncheckedExceptionExample {
    public static void main(String[] args) {
        int[] arr = new int[3];

        // Esto generará una ArrayIndexOutOfBoundsException
        System.out.println(arr[5]);
    }
}

---

Jerarquía de las Excepciones:

plaintext
Throwable
    |
    +-- Error
    |     +-- OutOfMemoryError
    |     +-- StackOverflowError
    |
    +-- Exception
          |
          +-- RuntimeException (Excepciones no verificadas)
          |     +-- NullPointerException
          |     +-- ArrayIndexOutOfBoundsException
          |     +-- ArithmeticException
          |     +-- IllegalArgumentException
          |
          +-- IOException (Excepciones verificadas)
          |     +-- FileNotFoundException
          |     +-- EOFException
          |
          +-- SQLException
          |
          +-- ClassNotFoundException
          |
          +-- ParseException