finally

// ── finally runs in all cases ────────────────────────────────────────
public void demonstrateFinally(boolean throwException) {
    System.out.println("Before try");
    try {
        System.out.println("In try");
        if (throwException) {
            throw new RuntimeException("test");
        }
        System.out.println("End of try (no exception)");
    } catch (RuntimeException e) {
        System.out.println("In catch: " + e.getMessage());
    } finally {
        System.out.println("In finally");  // ALWAYS runs
    }
    System.out.println("After try-catch-finally");
}

// demonstrateFinally(false) output:
// Before try
// In try
// End of try (no exception)
// In finally
// After try-catch-finally

// demonstrateFinally(true) output:
// Before try
// In try
// In catch: test
// In finally
// After try-catch-finally

// ── finally when exception is NOT caught ─────────────────────────────
public void withUncaughtException() {
    try {
        throw new IOException("uncaught");
        // No catch block for IOException
    } finally {
        System.out.println("Finally runs even without catch");
        // After finally, IOException propagates up the call stack
    }
}

// ── Resource acquisition before try, release in finally ───────────────
Connection conn = null;
try {
    conn = dataSource.getConnection();   // acquire BEFORE try
    conn.setAutoCommit(false);
    // ... business logic ...
    conn.commit();
} catch (SQLException e) {
    if (conn != null) {
        try { conn.rollback(); } catch (SQLException ex) { /* ignore */ }
    }
    throw new DataException("Operation failed", e);
} finally {
    if (conn != null) {
        try { conn.close(); }          // ALWAYS release
        catch (SQLException e) { log.warn("Failed to close connection", e); }
    }
}

// ── finally executes before return ───────────────────────────────────
public int returnFromTry() {
    try {
        System.out.println("try block");
        return 1;         // return value computed, stored...
    } finally {
        System.out.println("finally block");  // ...finally runs first...
    }
    // ...then method returns 1
}
// Output: "try block", "finally block"
// Returns: 1

// ── return in finally OVERRIDES return in try — dangerous ─────────────
public int dangerousReturn() {
    try {
        return 1;      // return 1 is computed and staged
    } finally {
        return 2;      // OVERRIDES — method returns 2, not 1!
    }
}
System.out.println(dangerousReturn());   // 2 — not 1!

// ── return in finally SUPPRESSES exceptions — extremely dangerous ──────
public String suppressingFinally() {
    try {
        throw new RuntimeException("important error");
    } finally {
        return "value";   // exception is SILENTLY DISCARDED — catastrophic!
    }
}
// No exception propagates — the RuntimeException is completely lost
// Returns "value" as if nothing went wrong

// ── Best practice: no return in finally ──────────────────────────────
// WRONG:
public int wrongFinally() {
    try {
        return computeResult();
    } finally {
        cleanup();
        return DEFAULT;   // BAD — hides exceptions, overrides real result
    }
}

// CORRECT: cleanup only, no return
public int correctFinally() {
    try {
        return computeResult();
    } finally {
        cleanup();   // cleanup only — no return, no throw (if possible)
    }
}

// ── Manual finally — verbose and has suppression problem ─────────────
// This is what try-with-resources replaces:
InputStream in = null;
OutputStream out = null;
try {
    in  = new FileInputStream("input.txt");
    out = new FileOutputStream("output.txt");
    byte[] buf = new byte[8192];
    int n;
    while ((n = in.read(buf)) != -1) out.write(buf, 0, n);
} finally {
    // Reversed order of acquisition:
    if (out != null) try { out.close(); } catch (IOException e) { /* suppress */ }
    if (in  != null) try { in.close();  } catch (IOException e) { /* suppress */ }
}
// 12 lines of boilerplate for resource management

// ── try-with-resources — automatic, correct, concise ─────────────────
try (InputStream in   = new FileInputStream("input.txt");
     OutputStream out = new FileOutputStream("output.txt")) {

    byte[] buf = new byte[8192];
    int n;
    while ((n = in.read(buf)) != -1) out.write(buf, 0, n);
}
// JVM automatically calls: out.close(), then in.close() (reverse order)
// Even if the body throws an exception

// ── Exception suppression — how try-with-resources handles dual throws ─
class BrokenResource implements AutoCloseable {
    @Override
    public void close() throws Exception {
        throw new Exception("close() threw");
    }
}

try (BrokenResource r = new BrokenResource()) {
    throw new RuntimeException("body threw");
    // body throws RuntimeException
    // JVM calls r.close(), which throws Exception
    // try-with-resources adds close() exception as SUPPRESSED:
    // RuntimeException is propagated
    // Exception from close() is r.getSuppressed()[0]
} catch (RuntimeException e) {
    System.out.println("Primary:   " + e.getMessage());        // body threw
    System.out.println("Suppressed:" + e.getSuppressed()[0].getMessage()); // close() threw
    // BOTH exceptions preserved — neither lost
}

// ── Custom AutoCloseable ──────────────────────────────────────────────
public class DatabaseTransaction implements AutoCloseable {

    private final Connection conn;
    private boolean committed = false;

    public DatabaseTransaction(Connection conn) throws SQLException {
        this.conn = conn;
        conn.setAutoCommit(false);
    }

    public void commit() throws SQLException {
        conn.commit();
        committed = true;
    }

    @Override
    public void close() throws SQLException {
        if (!committed) conn.rollback();   // rollback if not committed
        conn.setAutoCommit(true);
        conn.close();
    }
}

// Usage — automatic rollback on exception:
try (DatabaseTransaction tx = new DatabaseTransaction(
        dataSource.getConnection())) {
    orderRepo.save(order);
    paymentRepo.record(payment);
    tx.commit();
}   // auto-close: rolls back if exception, nothing if committed