Multi-catch Java — Finally Return Trap Silent Failure

package io.thecodeforge.java.exceptions;

import java.io.IOException;
import java.sql.SQLException;
import java.text.ParseException;

/**
 * Multi-catch simplifies code by grouping exceptions that require identical handling.
 */
public class MultiCatchDemo {
    public static void main(String[] args) {
        // Modern Java 7+ multi-catch — Clean and DRY (Don't Repeat Yourself)
        try {
            executeForgeTask();
        } catch (IOException | SQLException e) {
            // Note: 'e' is effectively final in a multi-catch block
            System.err.println("System Failure: " + e.getClass().getSimpleName() + " - " + e.getMessage());
            // log.error("Task failed", e); // Typical production logging
        }

        // Granular handling: Mix single and multi-catch
        try {
            executeForgeTask();
        } catch (IOException e) {
            handleIO(e);      // Specific logic for IO issues
        } catch (SQLException | ParseException e) {
            handleGeneric(e); // Shared logic for data integrity issues
        }
    }

    private static void executeForgeTask() throws IOException, SQLException, ParseException {}
    private static void handleIO(Exception e) {}
    private static void handleGeneric(Exception e) {}
}

package io.thecodeforge.java.exceptions;

public class FinallyFlowControl {
    public static void main(String[] args) {
        System.out.println("Result: " + processData());
    }

    /**
     * Demonstrates execution order. finally runs AFTER the try return value is determined,
     * but BEFORE control is handed back to the caller.
     */
    static String processData() {
        try {
            System.out.println("1. Inside Try");
            if (Math.random() > -1) return "Success"; // Triggering return
        } catch (Exception e) {
            System.out.println("Catch block executed");
        } finally {
            System.out.println("2. Finally block executed (the guarantee)");
        }
        return "Default";
    }

    /* 
     * SCENARIOS WHERE FINALLY DOES NOT RUN:
     * 1. System.exit(int) — JVM terminates immediately.
     * 2. Fatal JVM Error — e.g., OutOfMemoryError in the thread reaper.
     * 3. Hardware/Power Failure — The physical machine loses state.
     * 4. Infinite Loop/Deadlock — The thread never exits the try/catch block.
     */
}

package io.thecodeforge.java.exceptions;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * Manual resource closing in finally is deprecated in spirit. 
 * Try-with-resources handles 'Suppressed Exceptions' automatically.
 */
public class ResourceManagement {

    public static void readFile(String path) {
        // Any class implementing AutoCloseable can be used here
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            System.out.println("Content: " + reader.readLine());
        } catch (IOException e) {
            // If reader.close() also throws an exception, it's 'suppressed' 
            // and attached to this primary exception 'e'.
            System.err.println("Caught: " + e.getMessage());
            for (Throwable t : e.getSuppressed()) {
                System.err.println("Suppressed error during close: " + t.getMessage());
            }
        }
    }
}

package io.thecodeforge.java.exceptions;

public class FinallyReturnTrap {
    public static void main(String[] args) {
        System.out.println("Result: " + process());
    }

    // Always returns 42, ignoring the exception
    static int process() {
        try {
            throw new RuntimeException("Something went wrong");
        } finally {
            return 42;  // This swallows the exception!
        }
    }
}

package io.thecodeforge.java.exceptions;

import java.io.IOException;
import java.net.SocketTimeoutException;

public class PatternGuide {
    public static void main(String[] args) {
        // Good: identical handling
        try {
            // network call
        } catch (IOException | SocketTimeoutException e) {
            // Log and retry — same behaviour
            retry();
        }

        // Good: separate handling
        try {
            // file operation
        } catch (IOException e) {
            alertOps("File error: " + e.getMessage());
        } catch (SecurityException e) {
            rejectRequest("Access denied");
        }
    }

    private static void retry() {}
    private static void alertOps(String msg) {}
    private static void rejectRequest(String msg) {}
}