Java Exception Handling — try-catch-finally, Custom Exceptions & Best Practices

/*
 * java.lang.Throwable
 * ├── java.lang.Error                    ← Do NOT catch these
 * │   ├── OutOfMemoryError
 * │   ├── StackOverflowError
 * │   ├── NoClassDefFoundError
 * │   ├── AssertionError
 * │   └── VirtualMachineError
 * │
 * └── java.lang.Exception               ← Handle these
 *     ├── IOException           (CHECKED)
 *     │   ├── FileNotFoundException
 *     │   └── SocketException
 *     ├── SQLException          (CHECKED)
 *     ├── ClassNotFoundException (CHECKED)
 *     ├── ParseException        (CHECKED)
 *     ├── InterruptedException  (CHECKED)
 *     └── RuntimeException      (UNCHECKED — no compiler enforcement)
 *         ├── NullPointerException
 *         ├── IllegalArgumentException
 *         ├── IllegalStateException
 *         ├── ArrayIndexOutOfBoundsException
 *         ├── ClassCastException
 *         ├── ArithmeticException
 *         ├── NumberFormatException
 *         ├── UnsupportedOperationException
 *         └── ConcurrentModificationException
 */

// Demonstrating hierarchy with instanceof:
public class HierarchyDemo {
    public static void main(String[] args) {
        Exception e = new java.io.FileNotFoundException("config.yaml not found");

        System.out.println(e instanceof Throwable);                  // true
        System.out.println(e instanceof Exception);                  // true
        System.out.println(e instanceof java.io.IOException);        // true
        System.out.println(e instanceof java.io.FileNotFoundException); // true
        System.out.println(e instanceof RuntimeException);           // false

        // Catching a parent type catches all child types
        try {
            throw new java.io.FileNotFoundException("not found");
        } catch (java.io.IOException ioEx) {
            // ✅ Catches FileNotFoundException because it IS-A IOException
            System.out.println("Caught: " + ioEx.getClass().getSimpleName());
        }
    }
}

import java.io.*;

public class TryCatchFinallyDemo {

    // ── BASIC try-catch ────────────────────────────────
    public static void basicDemo() {
        try {
            int result = 10 / 0;  // Throws ArithmeticException
            System.out.println("This line never runs");
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage()); // / by zero
        }
        System.out.println("Program continues after catch");
    }

    // ── MULTIPLE catch blocks ──────────────────────────
    public static void multiCatchDemo(String input, int[] arr, int index) {
        try {
            int parsed  = Integer.parseInt(input); // NumberFormatException
            int element = arr[index];              // ArrayIndexOutOfBoundsException
            System.out.println(parsed + element);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number format: " + e.getMessage());
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index out of range: " + index);
        } catch (Exception e) {
            // General fallback — catches anything not caught above
            System.out.println("Unexpected error: " + e.getMessage());
        }
    }

    // ── finally block for cleanup ──────────────────────
    public static String readFirstLine(String filePath) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(filePath));
            return reader.readLine(); // May throw IOException
        } catch (FileNotFoundException e) {
            System.err.println("File not found: " + filePath);
            return null;
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
            return null;
        } finally {
            // ALWAYS runs — whether readLine() succeeded or threw
            if (reader != null) {
                try {
                    reader.close(); // Close the resource
                } catch (IOException closeEx) {
                    System.err.println("Failed to close reader");
                }
            }
            System.out.println("finally block: reader closed");
        }
    }

    // ── finally vs return — finally WINS ──────────────
    public static String finallyVsReturn() {
        try {
            System.out.println("In try");
            return "From try";   // return is noted, but finally runs first
        } finally {
            System.out.println("In finally"); // ← This ALWAYS runs
            // If we return here, it OVERRIDES the try's return!
            // return "From finally"; // ← Would override 'From try' — BAD PRACTICE
        }
    }
    // Output: 'In try' → 'In finally' → returns 'From try'

    public static void main(String[] args) {
        basicDemo();
        multiCatchDemo("abc", new int[]{1,2,3}, 5);
        System.out.println(finallyVsReturn());
    }
}

import java.io.*;
import java.sql.*;

public class ThrowVsThrowsDemo {

    // ── 'throws' in method signature ──────────────────
    // Declares: this method may propagate IOException to caller
    // Caller is FORCED to handle or re-declare it
    public String readConfig(String path) throws IOException {
        // If FileReader throws IOException, it propagates up
        BufferedReader br = new BufferedReader(new FileReader(path));
        return br.readLine();
    }

    // ── 'throw' in method body ────────────────────────
    // Developer explicitly creates and throws an exception
    public double divide(double numerator, double denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("Division by zero is not allowed");
        }
        return numerator / denominator;
    }

    // ── Both together: throw + throws ─────────────────
    public void processAge(int age) throws IllegalArgumentException {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException(
                "Age must be between 0 and 150, received: " + age);
        }
        System.out.println("Processing age: " + age);
    }
    // Note: IllegalArgumentException is unchecked — 'throws' is optional here
    // But declaring it documents the failure condition clearly

    // ── Multiple exceptions in throws ──────────────────
    public void saveUserData(String userId, String data)
            throws IOException, SQLException {
        // This method might throw either IOException or SQLException
        if (data == null)
            throw new IOException("Data cannot be null");
        // ... database save operation ...
    }

    // ── Caller must handle declared checked exceptions ─
    public void callerMethod() {
        // Option 1: catch it
        try {
            String config = readConfig("app.yml");
            System.out.println(config);
        } catch (IOException e) {
            System.err.println("Failed to read config: " + e.getMessage());
        }

        // Option 2: re-declare it (propagate further)
        // Add 'throws IOException' to this method's signature
    }

    // ── Re-throwing exceptions ─────────────────────────
    public void processFile(String path) throws IOException {
        try {
            String line = readConfig(path);
            if (line == null)
                throw new IOException("File is empty: " + path);
            // process...
        } catch (IOException e) {
            System.err.println("Processing failed, re-throwing...");
            throw e; // Re-throw the same exception
        }
    }
}

import java.io.*;
import java.text.*;

public class CheckedVsUnchecked {

    // ── CHECKED EXCEPTION — compiler enforces handling ─

    // Must declare 'throws IOException' — it's checked
    public static byte[] readFile(String path) throws IOException {
        return new FileInputStream(path).readAllBytes();
    }

    // Caller MUST handle IOException
    public static void callerOfReadFile() {
        try {
            byte[] content = readFile("data.bin");
            System.out.println("Read " + content.length + " bytes");
        } catch (IOException e) {
            // Meaningful recovery: use default, log, alert ops team
            System.err.println("File read failed: " + e.getMessage());
        }
        // ❌ If we omit the try-catch: compile error!
        // "Unhandled exception type IOException"
    }

    // ── UNCHECKED EXCEPTION — no compiler enforcement ──

    // No 'throws' needed — IllegalArgumentException is unchecked
    public static double calculateBMI(double weightKg, double heightMetres) {
        if (weightKg <= 0)
            throw new IllegalArgumentException("Weight must be positive: " + weightKg);
        if (heightMetres <= 0)
            throw new IllegalArgumentException("Height must be positive: " + heightMetres);
        return weightKg / (heightMetres * heightMetres);
    }

    // Caller may choose to catch or let it propagate
    public static void callerOfBMI() {
        // ✅ Legal without try-catch (unchecked)
        double bmi = calculateBMI(70, 1.75);
        System.out.println("BMI: " + bmi);

        // ✅ Also legal WITH try-catch for better UX
        try {
            double badBmi = calculateBMI(-5, 1.75);
        } catch (IllegalArgumentException e) {
            System.out.println("Input error: " + e.getMessage());
        }
    }

    // ── REAL-WORLD: When to choose which ──────────────

    // Checked: external resource — caller SHOULD handle
    public void connectToDatabase(String url, String user, String pass)
            throws java.sql.SQLException {
        // Network/DB failures are recoverable — caller should retry/fail gracefully
        java.sql.DriverManager.getConnection(url, user, pass);
    }

    // Unchecked: programming contract — caller shouldn't reach this if correct
    public void setPositiveAge(int age) {
        if (age < 0)
            throw new IllegalArgumentException(
                "Age cannot be negative. Caller has a bug.");
        // If caller passes valid age, this never throws
    }
}

import java.io.*;
import java.sql.*;
import java.text.*;

public class MultiCatchDemo {

    // ── SEPARATE CATCH BLOCKS — different handling ─────
    public static void separateCatchDemo(String filePath, String dateStr) {
        try {
            File file = new File(filePath);
            if (!file.exists())
                throw new FileNotFoundException("Config missing: " + filePath);

            SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
            java.util.Date date = sdf.parse(dateStr);

            System.out.println("File: " + file.getName() + ", Date: " + date);

        } catch (FileNotFoundException e) {
            // Specific handling: use a default config
            System.err.println("Config not found, using defaults: " + e.getMessage());
        } catch (ParseException e) {
            // Specific handling: reject the request
            System.err.println("Invalid date format at position " + e.getErrorOffset());
        } catch (Exception e) {
            // General fallback: log and alert
            System.err.println("Unexpected error: " + e.getClass().getName());
        }
    }

    // ── MULTI-CATCH (Java 7+) — same handling for multiple types ─
    public static void processUserRequest(String userId, String amount) {
        try {
            if (userId == null) throw new IllegalArgumentException("userId is null");
            double parsedAmount = Double.parseDouble(amount);
            int    parsedId     = Integer.parseInt(userId);
            System.out.println("Processing " + parsedAmount + " for user " + parsedId);

        } catch (NumberFormatException | IllegalArgumentException e) {
            // ✅ Multi-catch: both get same 'invalid input' handling
            System.err.println("[VALIDATION] Invalid input: " + e.getMessage());
            // 'e' is implicitly final here — cannot do: e = new Exception();
        } catch (Exception e) {
            System.err.println("[SYSTEM] Unexpected: " + e.getMessage());
        }
    }

    // ── CORRECT ORDER — specific before general ────────
    public static void correctOrderDemo() {
        try {
            Object[] arr = new String[3];
            arr[10] = "test"; // ArrayIndexOutOfBoundsException

        // ✅ Most specific first
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Array index error: " + e.getMessage());
        } catch (RuntimeException e) {
            System.err.println("Runtime error: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("General error: " + e.getMessage());
        }
    }

    // ── WRONG ORDER — compile error example ───────────
    // public static void wrongOrder() {
    //     try { throw new FileNotFoundException(); }
    //     catch (IOException e)           { }  // Catches parent
    //     catch (FileNotFoundException e) { }  // ❌ COMPILE ERROR!
    //     // FileNotFoundException already caught by IOException above
    // }
}

import java.io.*;
import java.sql.*;

public class TryWithResourcesDemo {

    // ── OLD WAY: try-finally — verbose and error-prone ─
    public static String readFileOldWay(String path) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(path));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) sb.append(line).append("\n");
            return sb.toString();
        } catch (IOException e) {
            System.err.println("Read error: " + e.getMessage());
            return null;
        } finally {
            if (reader != null) {
                try { reader.close(); }           // Must try-catch AGAIN
                catch (IOException e) { /* suppress */ }
            }
        }
    }

    // ── NEW WAY: try-with-resources — clean, safe ──────
    public static String readFileNewWay(String path) {
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) sb.append(line).append("\n");
            return sb.toString();
        } catch (IOException e) {
            System.err.println("Read error: " + e.getMessage());
            return null;
        }
        // reader.close() called automatically — even if exception is thrown
    }

    // ── MULTIPLE RESOURCES — closed in reverse order ───
    public static void copyFile(String srcPath, String destPath) throws IOException {
        try (
            InputStream  in  = new FileInputStream(srcPath);   // Opens first
            OutputStream out = new FileOutputStream(destPath)  // Opens second
        ) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            System.out.println("File copied successfully");
        }
        // out.close() called FIRST (reverse), then in.close()
        // Both closed even if exception occurs mid-copy
    }

    // ── CUSTOM AutoCloseable ───────────────────────────
    static class DatabaseTransaction implements AutoCloseable {
        private final Connection connection;
        private       boolean    committed;

        DatabaseTransaction(Connection conn) throws SQLException {
            this.connection = conn;
            this.connection.setAutoCommit(false);
            System.out.println("Transaction started");
        }

        public void commit() throws SQLException {
            connection.commit();
            committed = true;
            System.out.println("Transaction committed");
        }

        @Override
        public void close() throws SQLException {
            if (!committed) {
                connection.rollback(); // Auto-rollback if not committed
                System.out.println("Transaction rolled back");
            }
        }
    }

    public static void processOrder(Connection conn, Order order) throws SQLException {
        try (DatabaseTransaction tx = new DatabaseTransaction(conn)) {
            // Business logic
            saveOrder(conn, order);
            reserveInventory(conn, order);
            tx.commit(); // ← Only reaches here if no exception
        }
        // If saveOrder() or reserveInventory() throw: tx.close() rolls back
        // If commit() succeeds: tx.close() sees committed=true, skips rollback
    }

    // ── SUPPRESSED EXCEPTIONS ─────────────────────────
    public static void suppressedDemo() {
        try (
            AutoCloseable resource = () -> { throw new Exception("close() failed"); }
        ) {
            throw new RuntimeException("try block failed");
        } catch (Exception e) {
            System.out.println("Primary: " + e.getMessage()); // try block failed
            for (Throwable suppressed : e.getSuppressed()) {
                System.out.println("Suppressed: " + suppressed.getMessage()); // close() failed
            }
        }
    }

    static void saveOrder(Connection c, Order o) throws SQLException {}
    static void reserveInventory(Connection c, Order o) throws SQLException {}
    record Order(String id) {}
}

// ── BASE DOMAIN EXCEPTION ─────────────────────────────
public class ApplicationException extends RuntimeException {

    private final String errorCode;
    private final String userFriendlyMessage;

    public ApplicationException(String errorCode,
                                String techMessage,
                                String userMessage) {
        super(techMessage);
        this.errorCode          = errorCode;
        this.userFriendlyMessage = userMessage;
    }

    public ApplicationException(String errorCode,
                                String techMessage,
                                String userMessage,
                                Throwable cause) {
        super(techMessage, cause);
        this.errorCode          = errorCode;
        this.userFriendlyMessage = userMessage;
    }

    public String getErrorCode()          { return errorCode; }
    public String getUserFriendlyMessage() { return userFriendlyMessage; }
}

// ── VALIDATION EXCEPTIONS ─────────────────────────────
public class ValidationException extends ApplicationException {

    private final String fieldName;
    private final Object rejectedValue;

    public ValidationException(String fieldName, Object rejectedValue, String reason) {
        super("VALIDATION_ERROR",
              "Validation failed for '" + fieldName + "': " + reason,
              "Please check " + fieldName + " and try again.");
        this.fieldName     = fieldName;
        this.rejectedValue = rejectedValue;
    }

    public String getFieldName()    { return fieldName; }
    public Object getRejectedValue(){ return rejectedValue; }
}

// ── PAYMENT DOMAIN EXCEPTIONS ─────────────────────────
public class PaymentException extends ApplicationException {

    private final String transactionId;

    public PaymentException(String errorCode, String message,
                            String transactionId) {
        super(errorCode, message, "Payment could not be processed.");
        this.transactionId = transactionId;
    }

    public PaymentException(String errorCode, String message,
                            String transactionId, Throwable cause) {
        super(errorCode, message, "Payment could not be processed.", cause);
        this.transactionId = transactionId;
    }

    public String getTransactionId() { return transactionId; }
}

public class InsufficientFundsException extends PaymentException {

    private final double availableBalance;
    private final double requestedAmount;

    public InsufficientFundsException(double available,
                                      double requested,
                                      String transactionId) {
        super("INSUFFICIENT_FUNDS",
              String.format("Insufficient funds: available=%.2f, requested=%.2f",
                           available, requested),
              transactionId);
        this.availableBalance = available;
        this.requestedAmount  = requested;
    }

    public double getAvailableBalance() { return availableBalance; }
    public double getRequestedAmount()  { return requestedAmount; }

    public double getShortfallAmount() {
        return requestedAmount - availableBalance;
    }
}

// ── RESOURCE NOT FOUND ────────────────────────────────
public class ResourceNotFoundException extends ApplicationException {

    private final String resourceType;
    private final Object resourceId;

    public ResourceNotFoundException(String resourceType, Object id) {
        super("RESOURCE_NOT_FOUND",
              resourceType + " not found with id: " + id,
              resourceType + " not found.");
        this.resourceType = resourceType;
        this.resourceId   = id;
    }

    public String getResourceType() { return resourceType; }
    public Object getResourceId()   { return resourceId; }
}

// ── USAGE ─────────────────────────────────────────────
// try {
//     paymentService.processPayment(userId, amount);
// } catch (InsufficientFundsException e) {
//     // Specific recovery: show available balance to user
//     ui.showError("Need ₹" + e.getShortfallAmount() + " more to complete payment");
// } catch (PaymentException e) {
//     // General payment failure
//     ui.showError(e.getUserFriendlyMessage() + " [" + e.getErrorCode() + "]");
// } catch (ApplicationException e) {
//     // Any application-level error
//     logger.error("App error: {}", e.getErrorCode(), e);
// }

import java.sql.*;

// ── EXCEPTION CHAINING ────────────────────────────────
public class UserRepository {

    // ❌ BAD: Swallowing the original exception
    public User findUserBad(String userId) {
        try {
            return queryDatabase(userId);
        } catch (SQLException e) {
            // Original exception lost — impossible to diagnose root cause
            throw new RuntimeException("Database error");
        }
    }

    // ❌ ALSO BAD: Logging and rethrowing same type
    public User findUserAlsoBad(String userId) throws SQLException {
        try {
            return queryDatabase(userId);
        } catch (SQLException e) {
            // Logs it here AND caller might log again — duplicate logs
            System.err.println("DB error: " + e.getMessage());
            throw e; // Same exception — OK, but causes are lost if wrapped later
        }
    }

    // ✅ CORRECT: Wrap with cause — translate level, preserve context
    public User findUser(String userId) {
        try {
            return queryDatabase(userId);
        } catch (SQLException e) {
            // Higher-level exception with original cause preserved
            throw new DatabaseException(
                "Failed to retrieve user with id: " + userId, e);
            // ↑ 'e' stored as cause — getCause() returns it
        }
    }

    // ── READING THE CHAIN ─────────────────────────────
    public static void demonstrateChain() {
        try {
            // Simulate a chain: SocketException → SQLException → DatabaseException
            java.net.SocketException socketEx =
                new java.net.SocketException("Connection reset by peer");

            SQLException sqlEx = new SQLException(
                "Query execution failed", socketEx);

            DatabaseException dbEx = new DatabaseException(
                "User lookup failed", sqlEx);

            throw dbEx;

        } catch (DatabaseException e) {
            System.out.println("Top level: " + e.getMessage());

            // Walk the cause chain
            Throwable cause = e.getCause();
            int depth = 1;
            while (cause != null) {
                System.out.printf("  Cause[%d]: %s — %s%n",
                    depth++, cause.getClass().getSimpleName(), cause.getMessage());
                cause = cause.getCause();
            }
        }
        // Output:
        // Top level: User lookup failed
        //   Cause[1]: SQLException — Query execution failed
        //   Cause[2]: SocketException — Connection reset by peer
    }

    private User queryDatabase(String id) throws SQLException { return new User(id); }
    record User(String id) {}
}

class DatabaseException extends RuntimeException {
    public DatabaseException(String msg) { super(msg); }
    public DatabaseException(String msg, Throwable cause) { super(msg, cause); }
}

public class ExceptionPropagationDemo {

    // ── PROPAGATION CHAIN ─────────────────────────────
    // Level 3 — deepest — throws, does not catch
    static void level3() throws java.io.IOException {
        System.out.println("→ Entering level3");
        throw new java.io.IOException("Disk read failed at sector 47");
    }

    // Level 2 — middle — declares throws, does not catch
    static void level2() throws java.io.IOException {
        System.out.println("→ Entering level2");
        level3();  // Exception propagates up from level3
        System.out.println("← Leaving level2"); // Never reached
    }

    // Level 1 — catches the exception
    static void level1() {
        System.out.println("→ Entering level1");
        try {
            level2();
            System.out.println("← Leaving level2 (no exception)"); // Never reached
        } catch (java.io.IOException e) {
            System.out.println("★ Caught in level1: " + e.getMessage());
        }
        System.out.println("← Leaving level1 normally");
    }

    // Output when level1() is called:
    // → Entering level1
    // → Entering level2
    // → Entering level3
    // ★ Caught in level1: Disk read failed at sector 47
    // ← Leaving level1 normally

    // ── LAYERED ARCHITECTURE PROPAGATION ──────────────
    // This is how enterprise apps are SUPPOSED to handle exceptions

    // Data Access Layer — translates SQL to domain exception
    static User findUserInDb(String id) {
        try {
            // Simulate SQL call
            if (id == null) throw new java.sql.SQLException("Null parameter");
            return new User(id, "Test User");
        } catch (java.sql.SQLException e) {
            // Translate — don't expose JDBC to service layer
            throw new DatabaseException("DB lookup failed for user: " + id, e);
        }
    }

    // Service Layer — translates domain exception to business exception
    static User getUserService(String id) {
        try {
            return findUserInDb(id);
        } catch (DatabaseException e) {
            // Service-level context added
            throw new ServiceException("Cannot retrieve user profile", e);
        }
    }

    // Controller Layer — translates to HTTP response or UI message
    static String getUserController(String id) {
        try {
            User user = getUserService(id);
            return "200 OK: " + user;
        } catch (ServiceException e) {
            // Log with full cause chain, return user-friendly message
            System.err.println("Service error: " + e.getMessage());
            System.err.println("Root cause: " + e.getCause().getCause().getMessage());
            return "500 Internal Error: Unable to load profile";
        }
    }

    record User(String id, String name) {}
    static class ServiceException  extends RuntimeException {
        ServiceException(String m, Throwable c) { super(m, c); }
    }
}

import java.util.*;

public class CommonExceptionsDemo {

    // NullPointerException — and how to prevent it
    public static void npeDemo() {
        // ❌ NPE: calling on null
        String s = null;
        // s.length(); // Throws NullPointerException

        // ✅ Prevention 1: explicit null check
        if (s != null) System.out.println(s.length());

        // ✅ Prevention 2: Optional
        Optional.ofNullable(s).ifPresent(str -> System.out.println(str.length()));

        // ✅ Prevention 3: Objects.requireNonNull for constructor params
        String name = Objects.requireNonNull(s, "name cannot be null");
    }

    // ConcurrentModificationException — modifying during iteration
    public static void cmeDemo() {
        List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));

        // ❌ ConcurrentModificationException
        // for (String s : list) {
        //     if (s.equals("B")) list.remove(s);
        // }

        // ✅ Fix 1: Iterator.remove()
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            if (it.next().equals("B")) it.remove();
        }

        // ✅ Fix 2: removeIf (Java 8+) — cleanest
        list.removeIf(s -> s.equals("C"));

        System.out.println(list); // [A, D]
    }

    // StackOverflowError — missing base case
    public static int badFactorial(int n) {
        // ❌ No base case — infinite recursion
        return n * badFactorial(n - 1); // StackOverflowError
    }

    public static long goodFactorial(int n) {
        if (n < 0) throw new IllegalArgumentException("n must be >= 0");
        if (n <= 1) return 1; // ✅ Base case
        return n * goodFactorial(n - 1);
    }

    // NumberFormatException — parsing user input
    public static Optional<Integer> safeParseInt(String s) {
        try {
            return Optional.of(Integer.parseInt(s));
        } catch (NumberFormatException e) {
            return Optional.empty(); // Return empty Optional instead of throwing
        }
    }
    // Usage: safeParseInt("42") → Optional[42]
    //        safeParseInt("abc") → Optional.empty
}

// ❌ MISTAKE 1: Empty catch block — swallowing the exception silently
try {
    processPayment();
} catch (Exception e) {
    // ❌ Exception silently disappears — impossible to diagnose in production
}
// ✅ Fix: always at minimum log it
try {
    processPayment();
} catch (Exception e) {
    logger.error("Payment processing failed", e); // Log with full stack trace
    throw e; // Re-throw or throw a domain exception
}

// ❌ MISTAKE 2: Catching Exception (too broad) instead of specific types
try {
    int value = Integer.parseInt(userInput);
    File f = new File(filePath);
} catch (Exception e) {
    System.out.println("Something went wrong"); // Which thing? Can't tell
}
// ✅ Fix: specific catch blocks
try {
    int value = Integer.parseInt(userInput);
    File f = new File(filePath);
} catch (NumberFormatException e) {
    System.out.println("Invalid number format: " + e.getMessage());
} catch (SecurityException e) {
    System.out.println("File access denied: " + e.getMessage());
}

// ❌ MISTAKE 3: Catching exception without the cause — losing root cause
try {
    executeQuery();
} catch (SQLException e) {
    throw new RuntimeException("Database error"); // ❌ Cause lost!
}
// ✅ Fix: always pass cause to new exception
catch (SQLException e) {
    throw new DatabaseException("Query failed: " + e.getMessage(), e); // ✅
}

// ❌ MISTAKE 4: Using exceptions for normal control flow
public boolean userExists(String id) {
    try {
        getUser(id); // throws UserNotFoundException if not found
        return true;
    } catch (UserNotFoundException e) {
        return false; // ❌ Exception as conditional — expensive, poor design
    }
}
// ✅ Fix: return Optional or design API to check first
public Optional<User> findUser(String id) { /* ... */ return Optional.empty(); }

// ❌ MISTAKE 5: re-declaring unchecked exceptions in throws
// Not an error, but misleading and unnecessary
public void setAge(int age) throws NullPointerException { // ❌ Unnecessary
    if (age < 0) throw new IllegalArgumentException("Negative age");
}
// ✅ Fix: don't declare unchecked exceptions in throws (unless documenting)

// ❌ MISTAKE 6: Finally block with return statement
public int getValue() {
    try {
        return 1;
    } finally {
        return 2; // ❌ Overrides try's return AND swallows any exception!
    }
}
// Always returns 2, any exception in try is silently swallowed

// ❌ MISTAKE 7: Not closing resources in finally (before Java 7)
// or not using try-with-resources (Java 7+)
Connection conn = getConnection();
try {
    execute(conn);
} catch (SQLException e) {
    log(e);
    throw new RuntimeException(e);
    // ❌ conn.close() never reached — connection leak!
}
// ✅ Fix: try-with-resources
try (Connection conn2 = getConnection()) {
    execute(conn2);
} catch (SQLException e) {
    throw new DatabaseException("Execution failed", e);
} // conn2.close() called automatically

package com.techsustainify.payment.service;

import java.sql.*;
import java.util.Optional;
import java.util.logging.*;

public class PaymentService {

    private static final Logger log = Logger.getLogger(PaymentService.class.getName());

    private final PaymentRepository     paymentRepo;
    private final PaymentGatewayClient  gatewayClient;
    private final NotificationService   notificationService;
    private final AuditService          auditService;

    public PaymentService(PaymentRepository repo,
                          PaymentGatewayClient gateway,
                          NotificationService notifications,
                          AuditService audit) {
        this.paymentRepo       = java.util.Objects.requireNonNull(repo, "repo required");
        this.gatewayClient     = java.util.Objects.requireNonNull(gateway, "gateway required");
        this.notificationService = notifications;
        this.auditService        = audit;
    }

    /**
     * Processes a payment with full error handling.
     * Demonstrates: validation, checked/unchecked translation,
     * try-with-resources, exception chaining, and layered handling.
     */
    public PaymentResult processPayment(PaymentRequest request) {

        // Input validation — unchecked, detected early
        validatePaymentRequest(request);

        String txId = generateTransactionId();
        auditService.logAttempt(txId, request);

        try {
            // Gateway call — may throw GatewayException (unchecked)
            GatewayResponse response = gatewayClient.charge(
                request.getAmount(),
                request.getCurrency(),
                request.getPaymentMethod()
            );

            if (!response.isApproved()) {
                // Business failure — NOT an exception, just a result
                auditService.logDecline(txId, response.getDeclineCode());
                return PaymentResult.declined(response.getDeclineCode(),
                                             response.getDeclineMessage());
            }

            // Persist in DB using try-with-resources
            savePaymentRecord(txId, request, response);

            // Async notification — failures should NOT affect payment result
            notifyAsyncSafely(request, response, txId);

            auditService.logSuccess(txId);
            return PaymentResult.success(txId, response.getAuthCode());

        } catch (GatewayTimeoutException e) {
            // Retriable — caller can retry after delay
            log.log(Level.WARNING, "Payment gateway timeout for tx: " + txId, e);
            auditService.logFailure(txId, "GATEWAY_TIMEOUT");
            throw new RetryablePaymentException(
                "Payment gateway timed out — please retry",
                txId, 30, e);

        } catch (GatewayException e) {
            // Non-retriable gateway error
            log.log(Level.SEVERE, "Gateway error for tx: " + txId, e);
            auditService.logFailure(txId, "GATEWAY_ERROR");
            throw new PaymentProcessingException(
                "Payment gateway error: " + e.getMessage(),
                txId, e);

        } catch (DatabaseException e) {
            // Payment may have succeeded at gateway but not saved — critical
            log.log(Level.SEVERE,
                    "CRITICAL: Payment processed by gateway but save failed. tx=" + txId, e);
            auditService.logCriticalFailure(txId, e);
            // Alert ops team immediately
            throw new PaymentProcessingException(
                "Payment record save failed — manual intervention required. tx=" + txId,
                txId, e);
        }
    }

    private void validatePaymentRequest(PaymentRequest req) {
        if (req == null)
            throw new IllegalArgumentException("PaymentRequest cannot be null");
        if (req.getAmount() <= 0)
            throw new IllegalArgumentException("Amount must be positive: " + req.getAmount());
        if (req.getCurrency() == null || req.getCurrency().isBlank())
            throw new IllegalArgumentException("Currency is required");
        if (req.getPaymentMethod() == null)
            throw new IllegalArgumentException("Payment method is required");
    }

    private void savePaymentRecord(String txId,
                                    PaymentRequest req,
                                    GatewayResponse resp) {
        try (Connection conn = paymentRepo.getConnection()) {
            paymentRepo.save(conn, txId, req, resp);
        } catch (SQLException e) {
            // Translate JDBC exception to domain exception with full context
            throw new DatabaseException(
                "Failed to save payment record for tx: " + txId, e);
        } catch (Exception e) {
            throw new DatabaseException(
                "Unexpected DB error saving payment tx: " + txId, e);
        }
    }

    /** Notification failures must never affect payment success */
    private void notifyAsyncSafely(PaymentRequest req,
                                    GatewayResponse resp, String txId) {
        try {
            notificationService.sendPaymentConfirmation(req, resp, txId);
        } catch (Exception e) {
            // ✅ Intentional: notification failure does NOT fail the payment
            log.log(Level.WARNING, "Notification failed for tx: " + txId +
                    " — payment still successful", e);
        }
    }

    private String generateTransactionId() {
        return "TXN-" + java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 16);
    }
}

package com.techsustainify.file;

import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.logging.*;

public class FileProcessor {

    private static final Logger log = Logger.getLogger(FileProcessor.class.getName());
    private static final int    BUFFER_SIZE = 8192;

    /**
     * Reads a CSV file, processes each line, writes results.
     * Demonstrates: try-with-resources chaining, per-line error recovery,
     * and structured error reporting without aborting the whole batch.
     */
    public BatchResult processCSV(Path inputPath, Path outputPath) {
        List<String> errors       = new ArrayList<>();
        int          successCount = 0;
        int          lineNumber   = 0;

        // Both reader and writer auto-closed — writer closed FIRST (reverse order)
        try (
            BufferedReader reader = Files.newBufferedReader(inputPath);
            BufferedWriter writer = Files.newBufferedWriter(outputPath)
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                lineNumber++;
                final int currentLine = lineNumber; // Effectively final for lambda

                try {
                    // Per-line processing — errors DON'T abort the entire batch
                    String processed = processLine(line);
                    writer.write(processed);
                    writer.newLine();
                    successCount++;

                } catch (DataParsingException e) {
                    // Record error but continue with next line
                    String errorEntry = String.format(
                        "Line %d: %s — %s", currentLine, e.getRawData(), e.getMessage());
                    errors.add(errorEntry);
                    log.warning(errorEntry);

                } catch (Exception e) {
                    // Unexpected per-line error — record and continue
                    String errorEntry = String.format(
                        "Line %d: Unexpected error — %s", currentLine, e.getMessage());
                    errors.add(errorEntry);
                    log.log(Level.WARNING, errorEntry, e);
                }
            }

        } catch (NoSuchFileException e) {
            // Input file doesn't exist — fail fast, nothing to process
            throw new FileProcessingException(
                "Input file not found: " + inputPath, e);

        } catch (AccessDeniedException e) {
            throw new FileProcessingException(
                "Permission denied reading: " + inputPath +
                " or writing: " + outputPath, e);

        } catch (IOException e) {
            throw new FileProcessingException(
                "IO error during batch processing", e);
        }

        int totalLines = lineNumber;
        log.info(String.format(
            "Batch complete: %d/%d lines processed successfully, %d errors",
            successCount, totalLines, errors.size()));

        return new BatchResult(successCount, errors, totalLines);
    }

    private String processLine(String line) {
        if (line == null || line.isBlank())
            return "";
        String[] parts = line.split(",");
        if (parts.length < 3)
            throw new DataParsingException(
                "Expected 3+ columns, found " + parts.length, line);
        return String.join("|", parts).toUpperCase();
    }

    record BatchResult(int successCount, List<String> errors, int totalLines) {
        boolean hasErrors() { return !errors.isEmpty(); }
        double  successRate() { return totalLines == 0 ? 0 :
                                    (double) successCount / totalLines * 100; }
    }
}

class DataParsingException extends RuntimeException {
    private final String rawData;
    DataParsingException(String msg, String rawData) {
        super(msg); this.rawData = rawData;
    }
    String getRawData() { return rawData; }
}

class FileProcessingException extends RuntimeException {
    FileProcessingException(String msg, Throwable cause) { super(msg, cause); }
}