Java throws and throw Explained — Declaration, Delegation and Real-World Patterns

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());
        }
    }
}