Java try-catch-finally Explained: Flow, Pitfalls & Real Patterns

public class ExceptionFlowDemo {

    public static void main(String[] args) {
        System.out.println("=== Scenario 1: No exception thrown ===");
        readUserAge("25");

        System.out.println("\n=== Scenario 2: Recoverable exception ===");
        readUserAge("twenty");

        System.out.println("\n=== Scenario 3: Unhandled exception propagates ===");
        try {
            riskyDivision(10, 0);
        } catch (ArithmeticException ex) {
            // Caught one level up — finally still ran inside riskyDivision
            System.out.println("Caught in main: " + ex.getMessage());
        }
    }

    static void readUserAge(String input) {
        System.out.println("Attempting to parse: " + input);
        try {
            // This line throws NumberFormatException if input isn't a valid integer
            int age = Integer.parseInt(input);
            System.out.println("Parsed age: " + age); // Skipped if parse fails
        } catch (NumberFormatException ex) {
            // Only runs when Integer.parseInt() throws — not on success
            System.out.println("Bad input — couldn't parse '" + input + "' as a number.");
        } finally {
            // This ALWAYS runs — success or failure
            System.out.println("finally block executed for input: '" + input + "'");
        }
    }

    static int riskyDivision(int numerator, int denominator) {
        System.out.println("Inside riskyDivision — about to divide.");
        try {
            int result = numerator / denominator; // Throws ArithmeticException when denominator is 0
            System.out.println("Result: " + result); // Never reached when denominator is 0
            return result;
        } finally {
            // finally runs even though there's no catch here, and even though
            // the exception is about to propagate up to the caller
            System.out.println("riskyDivision finally block — always runs before propagation.");
        }
    }
}

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

public class ConfigFileReader {

    public static void main(String[] args) {
        // Test all three failure paths
        System.out.println(readConfigValue("app.properties", "timeout"));
        System.out.println(readConfigValue("/etc/shadow", "timeout"));
        System.out.println(readConfigValue("corrupt.properties", "timeout"));
    }

    /**
     * Reads a numeric config value from a properties file.
     * Returns a safe default (-1) if anything goes wrong.
     */
    static int readConfigValue(String filePath, String propertyKey) {
        System.out.println("\nReading '" + propertyKey + "' from: " + filePath);
        try {
            // Files.readString throws NoSuchFileException (subtype of IOException) if missing
            String fileContent = Files.readString(Path.of(filePath));

            // Simulate extracting a value — throws NumberFormatException if not a number
            String rawValue = extractProperty(fileContent, propertyKey);
            return Integer.parseInt(rawValue);

        } catch (NoSuchFileException ex) {
            // Most specific IOException subtype — file literally doesn't exist
            System.out.println("Config file not found: " + ex.getFile());
            System.out.println("Using default timeout.");
            return -1;

        } catch (AccessDeniedException ex) {
            // More specific than IOException — permission problem
            System.out.println("Permission denied reading: " + ex.getFile());
            return -1;

        } catch (IOException ex) {
            // General IO fallback — catches anything IO-related we didn't handle above
            System.out.println("IO error reading config: " + ex.getMessage());
            return -1;

        } catch (NumberFormatException ex) {
            // Unrelated to IOException — value existed but wasn't a valid integer
            System.out.println("Config value for '" + propertyKey + "' isn't a number: " + ex.getMessage());
            return -1;

        } finally {
            // Runs after any outcome — good place for audit logging in production
            System.out.println("Finished config read attempt for: " + filePath);
        }
    }

    static String extractProperty(String content, String key) {
        // Simplified parser — real code would use Properties class
        for (String line : content.split("\n")) {
            if (line.startsWith(key + "=")) {
                return line.split("=", 2)[1].trim();
            }
        }
        throw new NumberFormatException("Key '" + key + "' not found or has no value");
    }
}

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

public class ResourceCleanupComparison {

    public static void main(String[] args) throws IOException {
        System.out.println("=== Old style: manual finally cleanup ===");
        readFileOldStyle("sample.txt");

        System.out.println("\n=== Modern style: try-with-resources ===");
        readFileModernStyle("sample.txt");
    }

    // --- OLD STYLE (pre-Java 7) ---
    // Problem: if reader.close() throws, the original IOException from read() is lost
    static void readFileOldStyle(String fileName) throws IOException {
        BufferedReader reader = null; // Must declare outside try so finally can see it
        try {
            reader = new BufferedReader(new FileReader(fileName));
            String firstLine = reader.readLine();
            System.out.println("First line: " + firstLine);
        } catch (FileNotFoundException ex) {
            System.out.println("File not found: " + fileName);
        } finally {
            // We MUST null-check — if the constructor threw, reader is still null
            if (reader != null) {
                try {
                    reader.close(); // This can ALSO throw — swallowing the original exception
                    System.out.println("Reader closed in finally.");
                } catch (IOException closeException) {
                    System.out.println("Failed to close reader: " + closeException.getMessage());
                }
            }
        }
    }

    // --- MODERN STYLE (Java 7+) ---
    // BufferedReader implements AutoCloseable, so try-with-resources handles close() automatically
    // If both the body AND close() throw, the close exception is 'suppressed', not lost
    static void readFileModernStyle(String fileName) throws IOException {
        // Resource declared here is guaranteed to be closed when the block exits
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String firstLine = reader.readLine();
            System.out.println("First line: " + firstLine);
            // reader.close() is called automatically here — no finally needed
        } catch (FileNotFoundException ex) {
            // Much cleaner — all the IOException handling in one place
            System.out.println("File not found: " + fileName);
        }
        // No finally required — and no risk of suppressing the original exception
    }

    // Bonus: you can still combine try-with-resources AND a finally block if needed
    static void readAndAudit(String fileName) {
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            System.out.println(reader.readLine());
        } catch (IOException ex) {
            System.out.println("Read failed: " + ex.getMessage());
        } finally {
            // This still runs — useful for metrics, audit logs, etc.
            // reader is already closed BEFORE this finally block runs
            System.out.println("Audit: file read attempted for " + fileName);
        }
    }
}

public class FinallyReturnGotcha {

    public static void main(String[] args) {
        System.out.println("=== Gotcha 1: finally overrides try's return ===");
        int result = calculateBonus(true);
        System.out.println("Returned bonus: " + result); // You might expect 500, but...

        System.out.println("\n=== Gotcha 2: finally swallows exception ===");
        try {
            processPayment(-100);
        } catch (Exception ex) {
            // Which exception do we actually catch here?
            System.out.println("Caught: " + ex.getClass().getSimpleName() + " — " + ex.getMessage());
        }
    }

    static int calculateBonus(boolean isEligible) {
        try {
            if (isEligible) {
                System.out.println("try: returning 500");
                return 500; // This return value is computed...
            }
            return 0;
        } finally {
            // ...but finally runs before the method actually returns
            // and this return REPLACES the 500 from try
            System.out.println("finally: overriding return to 0");
            return 0; // DON'T DO THIS — the caller gets 0, not 500
        }
    }

    static void processPayment(int amount) {
        try {
            if (amount < 0) {
                throw new IllegalArgumentException("Payment amount cannot be negative: " + amount);
            }
            System.out.println("Payment processed: " + amount);
        } finally {
            // Simulating a bug: cleanup code that also throws
            // This completely hides the IllegalArgumentException above
            throw new RuntimeException("Cleanup failed"); // DON'T DO THIS EITHER
        }
    }
}