Error vs Exception

// ── Throwable hierarchy: ─────────────────────────────────────────────
//
//  Throwable
//  ├── Exception                     ← application-level failures
//  │   ├── IOException               ← checked (anticipated)
//  │   ├── SQLException              ← checked
//  │   ├── ParseException            ← checked
//  │   └── RuntimeException          ← unchecked (programming errors)
//  │       ├── NullPointerException
//  │       ├── IllegalArgumentException
//  │       ├── ArrayIndexOutOfBoundsException
//  │       └── ClassCastException
//  └── Error                         ← JVM-level failures
//      ├── OutOfMemoryError          ← heap exhausted
//      ├── StackOverflowError        ← call stack full
//      ├── VirtualMachineError       ← JVM internal error
//      │   ├── OutOfMemoryError
//      │   └── InternalError
//      ├── AssertionError            ← assert statement failed
//      ├── LinkageError              ← class loading/linking failed
//      │   ├── NoClassDefFoundError
//      │   └── ClassCircularityError
//      └── ThreadDeath               ← deprecated thread stop mechanism

// ── Catching the hierarchy: ───────────────────────────────────────────
try {
    // some code
} catch (RuntimeException e) {
    // catches NullPointerException, IllegalArgumentException, etc.
} catch (Exception e) {
    // catches checked exceptions: IOException, SQLException, etc.
} catch (Error e) {
    // catches JVM errors — generally should NOT be done
} catch (Throwable t) {
    // catches EVERYTHING — generally should NOT be done in app code
}

// ── OutOfMemoryError — heap exhaustion: ──────────────────────────────
try {
    List<byte[]> leak = new ArrayList<>();
    while (true) {
        leak.add(new byte[1_000_000]);   // allocate 1MB continuously
    }
} catch (OutOfMemoryError e) {
    System.err.println("Out of memory: " + e.getMessage());
    // At this point, memory is critically low.
    // The only safe action is to release large references and exit or
    // let the process die. Attempting complex recovery is dangerous.
}

// Common causes:
// 1. Memory leak — objects held in static collections:
private static final List<Object> cache = new ArrayList<>();
// Items added to cache but never removed — grows forever

// 2. Reading entire large file into memory:
// byte[] data = Files.readAllBytes(Path.of("huge-file.dat"));  // OOM for large files
// Better: process in chunks with streaming

// ── StackOverflowError — infinite recursion: ─────────────────────────
public static int badFactorial(int n) {
    return n * badFactorial(n - 1);  // no base case — infinite recursion!
}

try {
    badFactorial(10);
} catch (StackOverflowError e) {
    System.err.println("Stack overflow — check for infinite recursion");
}

// Correct — with base case:
public static long factorial(int n) {
    if (n <= 1) return 1;           // base case prevents infinite recursion
    return n * factorial(n - 1);
}

// ── AssertionError — assertion failure (with -ea flag): ───────────────
public int divide(int a, int b) {
    assert b != 0 : "Divisor must not be zero (called with b=" + b + ")";
    return a / b;
}
// Run with -ea to enable assertions in development.
// AssertionError thrown if b == 0.

// ── NoClassDefFoundError — class found at compile time but not runtime: ─
// Example: code compiled with json-lib.jar in classpath, but jar missing at runtime.
// At runtime, accessing com.example.JsonParser throws NoClassDefFoundError.
// ClassNotFoundException: thrown by Class.forName() when class simply not found.

try {
    Class.forName("com.example.OptionalClass");
} catch (ClassNotFoundException e) {
    System.out.println("Optional class not available: " + e.getMessage());
    // ClassNotFoundException is CHECKED — must be handled.
}

// ── Do NOT do this in normal application code: ───────────────────────
try {
    processLargeDataset(data);
} catch (OutOfMemoryError e) {
    System.out.println("Low memory — retrying with smaller batch");
    processSmallBatch(data);  // DANGEROUS — memory is critically low,
                               // this allocation may also fail,
                               // and data may be in corrupted state
}

// ── Legitimate narrow use — framework-level catch for graceful shutdown: ─
public class RequestHandler implements Runnable {
    @Override
    public void run() {
        try {
            handleRequest(request);
        } catch (Exception e) {
            // Normal exception handling:
            logger.error("Request handling failed", e);
            sendErrorResponse(500, "Internal server error");
        } catch (Error e) {
            // Narrow Error catch — minimal actions only:
            try {
                logger.error("JVM error during request handling", e);
                sendErrorResponse(500, "Server error");
            } catch (Throwable t) {
                // Even this may fail — give up
            }
            // Do NOT try to continue — re-throw or exit:
            throw e;
        }
    }
}

// ── Top-level uncaught exception handler — preferred approach: ────────
Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
    System.err.println("Uncaught exception in thread " + thread.getName());
    throwable.printStackTrace(System.err);
    // Optional: alert monitoring, write crash report
    System.exit(1);   // clean exit
});

// ── finally still executes — use for cleanup: ─────────────────────────
Connection conn = null;
try {
    conn = dataSource.getConnection();
    // ... use connection ...
} catch (SQLException e) {
    logger.error("SQL error", e);
} finally {
    if (conn != null) {
        try { conn.close(); } catch (SQLException ignored) { }
        // Connection closed even if OutOfMemoryError was thrown
    }
}

// ── Comparison summary: ───────────────────────────────────────────────
//
//                Exception              Error
// ────────────── ──────────────────     ──────────────────────────
// Extends        Throwable              Throwable
// Represents     Application failure    JVM/environment failure
// Should catch?  Yes (usually)          No (almost never)
// Compiler check Checked subclasses     Neither checked nor unchecked
// Recovery       Often possible         Rarely possible
// Common types   IOException, NPE       OOM, StackOverflow, NoClassDef
// Application    Handle, log, retry     Log and shut down