¿Cómo se manejan los errores en Java y cómo trabajar con ellos?

En Java, los errores se manejan mediante el mecanismo de excepciones. Las excepciones representan eventos que interrumpen el flujo normal de ejecución del programa. Existen dos tipos de excepciones: Excepciones Comprobadas (Checked Exceptions) y Excepciones No Comprobadas (Unchecked Exceptions).

Excepciones Comprobadas:

• Heredan de java.lang.Exception (excepto RuntimeException).
• Deben ser manejadas (usando try-catch) o declaradas en la firma del método (usando throws).
• Representan errores que pueden ocurrir en condiciones normales (por ejemplo, IOException, FileNotFoundException).

Excepciones No Comprobadas:

• Heredan de java.lang.RuntimeException o java.lang.Error.
• No requieren manejo o declaración obligatoria.
• Representan errores que a menudo indican errores lógicos en el código o estados anómalos del entorno de ejecución (por ejemplo, NullPointerException, ArrayIndexOutOfBoundsException).

Manejo de excepciones:

Para manejar excepciones se utilizan bloques try-catch-finally:

• try: Bloque de código que puede generar una excepción.
• catch: Bloque de código que se ejecuta si en el bloque try ocurre una excepción del tipo especificado. Se pueden tener varios bloques catch para diferentes tipos de excepciones.
• finally: Bloque de código que se ejecuta independientemente de si ocurrió o no una excepción. Se usa a menudo para liberar recursos (por ejemplo, cerrar archivos, conexiones).

try {
    // Código que puede lanzar una excepción
    int result = 10 / 0; // Ejemplo: ArithmeticException
} catch (ArithmeticException e) {
    // Manejo de ArithmeticException
    System.err.println("Error de división por cero: " + e.getMessage());
    // Se puede registrar el error, mostrar un mensaje al usuario, etc.
} catch (Exception e) {
    // Manejo de cualquier otra excepción si no fue manejada anteriormente
    System.err.println("Ocurrió un error general: " + e.getMessage());
} finally {
    // Código que siempre se ejecuta
    System.out.println("Bloque finally ejecutado.");
}

Propagación de excepciones:

Un método puede declarar que puede generar una excepción específica usando la palabra clave throws:

public void readFile(String filePath) throws FileNotFoundException, IOException {
    // Código para leer un archivo
    // Si el archivo no se encuentra, puede lanzarse FileNotFoundException (subclase de IOException)
    FileReader fr = new FileReader(filePath);
    // Si ocurre un error de entrada/salida, puede lanzarse IOException
    // ...
}

El método que llama debe manejar esta excepción (try-catch) o también declararla con throws.

Creación de excepciones propias:

Se pueden crear clases de excepciones personalizadas que heredan de Exception (para Excepciones Comprobadas) o RuntimeException (para Excepciones No Comprobadas).

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

Uso:

public void processData(int value) throws MyCustomException {
    if (value < 0) {
        throw new MyCustomException("El valor no puede ser negativo");
    }
    // Procesamiento de datos
}

Clases principales de excepciones (jerarquía):

• java.lang.Throwable (clase base para todos los errores y excepciones)
  • java.lang.Error (para problemas graves que generalmente no son manejados por el programa, por ejemplo, OutOfMemoryError)
  • java.lang.Exception (para excepciones que el programa puede manejar)
    • java.lang.RuntimeException (Excepciones No Comprobadas)
      • NullPointerException
      • ArrayIndexOutOfBoundsException
      • ArithmeticException
      • etc.
    • Otras subclases de Exception (Excepciones Comprobadas)
      • IOException
      • FileNotFoundException
      • SQLException
      • etc.

Trabajar con errores implica entender esta jerarquía, elegir el tipo de excepción adecuado (al crear las propias), usar eficazmente try-catch-finally para manejar y propagar excepciones, y también registrar errores para depuración.