throws in Java — The Silent Data Loss Anti-Pattern

public class BankAccount {

    private final String accountHolder;
    private double balance;

    public BankAccount(String accountHolder, double initialBalance) {
        // Guard the constructor — negative starting balance makes no business sense
        if (initialBalance < 0) {
            // throw immediately creates an exception object and hands control
            // to the nearest matching catch block up the call stack
            throw new IllegalArgumentException(
                "Initial balance cannot be negative. Received: " + initialBalance
            );
        }
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
    }

    public void withdraw(double amount) {
        // Validate the amount itself first
        if (amount <= 0) {
            throw new IllegalArgumentException(
                "Withdrawal amount must be positive. Received: " + amount
            );
        }
        // Then validate the business rule — can't overdraw this account
        if (amount > balance) {
            throw new IllegalStateException(
                "Insufficient funds. Balance: " + balance + ", Requested: " + amount
            );
        }
        balance -= amount;
        System.out.println("Withdrew $" + amount + ". New balance: $" + balance);
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount("Alice", 500.00);

        account.withdraw(200.00); // succeeds

        try {
            account.withdraw(400.00); // fails — only $300 left
        } catch (IllegalStateException bankingError) {
            // We catch the specific type we expect from this operation
            System.out.println("Transaction denied: " + bankingError.getMessage());
        }

        try {
            // This will hit the constructor guard
            BankAccount badAccount = new BankAccount("Bob", -100);
        } catch (IllegalArgumentException setupError) {
            System.out.println("Account creation failed: " + setupError.getMessage());
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class UserDataLoader {

    // This method declares throws IOException because FileReader can throw it.
    // We're not handling it here — we're delegating the decision to whoever calls us.
    // The caller is in a better position to decide: retry? show a dialog? log and exit?
    public String readUserProfile(String filePath) throws IOException {
        StringBuilder profileContent = new StringBuilder();

        // FileReader throws IOException if the file doesn't exist or can't be opened
        // We let that propagate — we added it to our throws clause above
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String currentLine;
            while ((currentLine = reader.readLine()) != null) {
                profileContent.append(currentLine).append("\n");
            }
        }
        // No catch block — IOException will automatically propagate to our caller
        return profileContent.toString();
    }

    // This method declares TWO possible checked exceptions.
    // A method can throw multiple exception types, separated by commas.
    public Date parseUserBirthdate(String rawDateString) throws ParseException, IllegalArgumentException {
        if (rawDateString == null || rawDateString.isBlank()) {
            // IllegalArgumentException is unchecked, so it doesn't NEED to be in throws,
            // but we include it here to document the contract explicitly
            throw new IllegalArgumentException("Birthdate string must not be null or blank");
        }

        SimpleDateFormat expectedFormat = new SimpleDateFormat("yyyy-MM-dd");
        expectedFormat.setLenient(false); // "2023-02-31" should fail, not silently roll over

        // parse() throws ParseException if the string doesn't match — checked, so it propagates
        return expectedFormat.parse(rawDateString);
    }

    public static void main(String[] args) {
        UserDataLoader loader = new UserDataLoader();

        // --- Calling a method with throws IOException ---
        // The compiler FORCES us to handle it. We can't just call loader.readUserProfile() and move on.
        try {
            String profile = loader.readUserProfile("user_profile.txt");
            System.out.println("Profile loaded:");
            System.out.println(profile);
        } catch (IOException fileError) {
            // In a real app you'd log this with a proper logger (SLF4J, Log4j, etc.)
            System.out.println("Could not load profile: " + fileError.getMessage());
        }

        // --- Calling a method that throws ParseException ---
        try {
            Date birthdate = loader.parseUserBirthdate("1990-07-15");
            System.out.println("Parsed birthdate: " + birthdate);

            // Now try a badly formatted date
            Date badDate = loader.parseUserBirthdate("15/07/1990");
        } catch (ParseException formatError) {
            System.out.println("Date format was wrong: " + formatError.getMessage());
        }
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

// Custom checked exception — this is what the service layer will see.
// It's at the right level of abstraction: 'something went wrong with data access'.
class DataAccessException extends Exception {
    public DataAccessException(String message, Throwable cause) {
        // Passing 'cause' to super() is exception chaining.
        // The original exception is preserved and accessible via getCause().
        super(message, cause);
    }
}

public class UserRepository {

    private static final String DB_URL = "jdbc:mysql://localhost:3306/appdb";

    // This method's throws clause uses OUR abstraction (DataAccessException),
    // not the low-level SQL one. Callers don't need to import java.sql.*
    public String findUsernameById(int userId) throws DataAccessException {
        String query = "SELECT username FROM users WHERE id = ?";

        try (
            Connection dbConnection = DriverManager.getConnection(DB_URL, "appuser", "secret");
            PreparedStatement statement = dbConnection.prepareStatement(query)
        ) {
            statement.setInt(1, userId);
            ResultSet results = statement.executeQuery();

            if (results.next()) {
                return results.getString("username");
            } else {
                // Using throw with a custom message for a business-level 'not found' situation
                throw new DataAccessException(
                    "No user found with ID: " + userId, null
                );
            }

        } catch (SQLException databaseError) {
            // We CATCH the low-level SQLException, then THROW our own exception.
            // The original databaseError is passed as the cause — we don't lose it.
            throw new DataAccessException(
                "Database error while looking up user ID: " + userId,
                databaseError  // <-- This is the chaining part
            );
        }
    }

    // The service layer calls us and handles DataAccessException.
    // It never needs to know about JDBC or SQL at all.
    public static void main(String[] args) {
        UserRepository repository = new UserRepository();

        try {
            String username = repository.findUsernameById(42);
            System.out.println("Found user: " + username);
        } catch (DataAccessException serviceError) {
            System.out.println("Service error: " + serviceError.getMessage());

            // getCause() gives us the original low-level exception for debugging
            if (serviceError.getCause() != null) {
                System.out.println("Root cause: " + serviceError.getCause().getMessage());
            }
        }
    }
}

public class ExceptionMistakesDemo {

    // ─────────────────────────────────────────────────────
    // MISTAKE 1: Throwing inside finally — swallows the original exception
    // ─────────────────────────────────────────────────────
    public static void riskyOperation() throws Exception {
        try {
            System.out.println("Attempting risky operation...");
            throw new Exception("Something went wrong in the try block");
        } finally {
            // BAD: If finally also throws, the original exception from try is SILENTLY LOST.
            // The caller only sees 'Cleanup failed', never knowing about the first error.
            // throw new RuntimeException("Cleanup failed"); // <-- DON'T do this

            // GOOD: Do cleanup, but don't throw from finally unless you're certain
            // the cleanup exception is more important than the original.
            System.out.println("Cleanup complete (no throw from finally)");
        }
    }

    // ─────────────────────────────────────────────────────
    // MISTAKE 2: Catching Exception (or Throwable) too broadly
    // ─────────────────────────────────────────────────────
    public static void broadCatchAntiPattern(String input) {
        try {
            int parsed = Integer.parseInt(input);       // throws NumberFormatException
            int result = 100 / parsed;                  // throws ArithmeticException if input is "0"
            System.out.println("Result: " + result);
        } catch (Exception everythingCatch) {
            // BAD: We have no idea WHICH exception happened.
            // NumberFormatException needs a different response than ArithmeticException.
            System.out.println("Something failed: " + everythingCatch.getMessage());
        }

        // GOOD: Catch specifically, handle meaningfully
        try {
            int parsed = Integer.parseInt(input);
            int result = 100 / parsed;
            System.out.println("Result: " + result);
        } catch (NumberFormatException inputError) {
            System.out.println("Input is not a valid number: " + input);
        } catch (ArithmeticException mathError) {
            System.out.println("Cannot divide by zero — input must not be 0");
        }
    }

    // ─────────────────────────────────────────────────────
    // MISTAKE 3: Using throws with unchecked exceptions unnecessarily
    // and confusing it with actually handling them
    // ─────────────────────────────────────────────────────
    // This compiles and runs fine, but the throws NullPointerException is noise.
    // NullPointerException is unchecked — declaring it in throws doesn't make callers
    // handle it, it just clutters your method signature.
    public static String getUpperCase(String text) throws NullPointerException { // <-- noisy
        return text.toUpperCase(); // will throw NPE if text is null anyway
    }

    // GOOD: For unchecked exceptions, validate defensively instead
    public static String getUpperCaseSafe(String text) {
        if (text == null) {
            throw new IllegalArgumentException("text must not be null"); // intentional, meaningful
        }
        return text.toUpperCase();
    }

    public static void main(String[] args) throws Exception {
        riskyOperation();

        System.out.println("\n--- Broad catch demo ---");
        broadCatchAntiPattern("abc");  // NumberFormatException path
        broadCatchAntiPattern("0");    // ArithmeticException path
        broadCatchAntiPattern("5");    // success path

        System.out.println("\n--- Safe null handling demo ---");
        System.out.println(getUpperCaseSafe("hello"));
        try {
            getUpperCaseSafe(null);
        } catch (IllegalArgumentException validationError) {
            System.out.println("Caught expected error: " + validationError.getMessage());
        }
    }
}

import java.io.IOException;
import java.net.ConnectException;
import java.net.URL;
import java.net.HttpURLConnection;

// Pattern: Recovery-oriented exception hierarchy
class ServiceException extends Exception {
    public ServiceException(String message, Throwable cause) {
        super(message, cause);
    }
}

class RetryableException extends ServiceException {
    public RetryableException(String message, Throwable cause) {
        super(message, cause);
    }
}

class NonRetryableException extends ServiceException {
    public NonRetryableException(String message, Throwable cause) {
        super(message, cause);
    }
}

class ResourceNotFoundException extends ServiceException {
    public ResourceNotFoundException(String resourceId) {
        super("Resource not found: " + resourceId, null);
    }
}

public class ExceptionPatternsDemo {

    // Pattern: Abstraction boundary
    public String fetchUserProfile(int userId) throws ServiceException {
        try {
            String url = "https://api.example.com/users/" + userId;
            HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
            conn.setConnectTimeout(5000);

            if (conn.getResponseCode() == 404) {
                throw new ResourceNotFoundException(String.valueOf(userId));
            }

            if (conn.getResponseCode() >= 500) {
                // Connection to upstream failed — retryable
                throw new RetryableException(
                    "Upstream returned " + conn.getResponseCode(),
                    new IOException("HTTP " + conn.getResponseCode())
                );
            }

            return "User profile data";
        } catch (ConnectException networkTimeout) {
            // Network timeout is retryable
            throw new RetryableException("Network timeout fetching user " + userId, networkTimeout);
        } catch (IOException otherIO) {
            // Other IO errors are probably not retryable (e.g., bad URL)
            throw new NonRetryableException("IO error fetching user " + userId, otherIO);
        }
    }

    public static void main(String[] args) {
        ExceptionPatternsDemo client = new ExceptionPatternsDemo();

        try {
            String profile = client.fetchUserProfile(42);
            System.out.println("Profile: " + profile);
        } catch (RetryableException retryable) {
            // Caller knows they can retry after a backoff
            System.out.println("Will retry: " + retryable.getMessage());
        } catch (ResourceNotFoundException notFound) {
            // Caller knows to show 404
            System.out.println("User not found: " + notFound.getMessage());
        } catch (NonRetryableException fatal) {
            // Caller knows to alert immediately
            System.err.println("Fatal error: " + fatal.getMessage());
        } catch (ServiceException generic) {
            // Fallback for any other service error
            System.err.println("Service error: " + generic.getMessage());
        }
    }
}

// io.thecodeforge — java tutorial

public class ThrowableHierarchy {
    public static void main(String[] args) {
        // This WILL crash. Don't catch Error in real code.
        try {
            recurseUntilStackOverflow(1);
        } catch (StackOverflowError e) {
            System.out.println("Caught Error: " + e.getClass().getSimpleName());
            // System still unstable. Log and abort.
        }

        // This is standard checked exception handling
        try {
            readConfig("/etc/app/config");
        } catch (Exception e) {
            System.out.println("Caught checked Exception: " + e.getClass().getSimpleName());
        }
    }

    static void recurseUntilStackOverflow(int count) {
        recurseUntilStackOverflow(count + 1);
    }

    static void readConfig(String path) throws java.io.IOException {
        if (!new java.io.File(path).exists()) {
            throw new java.io.IOException("Config not found: " + path);
        }
    }
}

// io.thecodeforge — java tutorial

import java.io.*;

public class CheckedVsUnchecked {
    // Checked: caller MUST handle or declare
    public static String readFirstLine(String path) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            return reader.readLine();
        }
    }

    // Unchecked: caller MAY handle, but shouldn't need to
    public static int parseId(String input) {
        if (input == null) {
            throw new IllegalArgumentException("Input cannot be null");
        }
        return Integer.parseInt(input);
    }

    public static void main(String[] args) {
        // Caller for checked exception: must handle
        try {
            String line = readFirstLine("/tmp/data.csv");
            System.out.println("Read: " + line);
        } catch (IOException e) {
            System.out.println("Handled checked: " + e.getMessage());
        }

        // Caller for unchecked: no try-catch needed
        int id = parseId("42");
        System.out.println("Parsed ID: " + id);
    }
}