¿Cómo funciona el manejo de excepciones y la distinción entre excepciones marcadas y no marcadas?

Question

Accepted Answer

Java maneja errores con **`try`/`catch`/`finally`** y distingue de manera única entre excepciones **marcadas** (deben ser declaradas o manejadas) y excepciones **no marcadas** (tiempo de ejecución, no obligadas). Comprender esta distinción es fundamental para el manejo de errores en Java.

## La estructura básica

```java
try {
    FileReader f = new FileReader("file.txt");   // may throw IOException
    // ... use it ...
} catch (FileNotFoundException e) {
    System.out.println("not found: " + e.getMessage()); // specific first
} catch (IOException e) {
    System.out.println("io error");                      // broader after
} finally {
    System.out.println("always runs — cleanup");         // runs no matter what
}
```

`finally` siempre se ejecuta (limpieza), incluso si se lanza una excepción o ocurre un `return`.

## La jerarquía de excepciones

```text
Throwable
  ├── Error            — serious JVM problems (OutOfMemoryError) — don't catch
  └── Exception
        ├── RuntimeException  → UNCHECKED (not enforced by the compiler)
        │     NullPointerException, IllegalArgumentException, IndexOutOfBounds...
        └── (other Exceptions) → CHECKED (compiler enforces handling)
              IOException, SQLException...
```

## Excepciones marcadas — impuestas por el compilador

```java
// MUST either catch it or declare `throws` — the compiler won't let you ignore it
public void readFile() throws IOException {   // declare it
    Files.readAllLines(Paths.get("file.txt")); // throws checked IOException
}
```

Las excepciones **marcadas** (IOException, SQLException) representan condiciones recuperables esperadas (un archivo faltante, una falla de red). El compilador *te obliga* a manejarlas o declararlas — haciendo explícito el manejo de fallos externos.

## Excepciones no marcadas — tiempo de ejecución, no obligadas

```java
// NOT required to declare or catch — usually indicate PROGRAMMING BUGS
String s = null;
s.length();                       // NullPointerException (unchecked)
int x = arr[10];                   // ArrayIndexOutOfBoundsException (unchecked)
Integer.parseInt("abc");           // NumberFormatException (unchecked)
```

Las excepciones **no marcadas** (subclases de RuntimeException) generalmente señalan errores de programación — se corrige el error en lugar de atraparlo en todas partes. El compilador no impone el manejo.

## try-with-resources (limpieza automática)

```java
// resources implementing AutoCloseable are closed automatically
try (FileReader f = new FileReader("file.txt")) {
    // use f
}   // f.close() called automatically, even on exception — no finally needed
```

## Mejores prácticas

```text
✓ Catch specific exceptions, not bare Exception
✓ Use try-with-resources for files/connections (auto-close)
✓ Don't swallow exceptions silently (empty catch blocks)
✓ Throw meaningful exceptions; include context in messages
✓ Custom exceptions extend Exception (checked) or RuntimeException (unchecked)
```

## Por qué es importante

El manejo robusto de errores es esencial, y la **distinción marcado/no marcado de Java es una característica definitoria (y debatida)** que merece ser entendida profundamente.

Las excepciones marcadas imponen manejo explícito de fallos externos esperados (I/O, DB) — promoviendo confiabilidad pero a veces criticadas como verbosas; las excepciones no marcadas representan errores que se deben corregir en lugar de capturar rutinariamente.

Conocer la jerarquía, cuándo se aplica cada tipo, la semántica `try/catch/finally` y el moderno **try-with-resources** para limpieza automática es fundamental para escribir Java correcto y confiable — y para diseñar tus propias excepciones apropiadamente.

La distinción da forma a cómo se diseñan las API de Java y es un tema frecuente en entrevistas y revisiones de código.