Exception Handling in OOP

Exception Handling is a mechanism to handle runtime errors (file not found, division by zero, null pointer access) gracefully, without crashing the entire program. It separates error-handling code from normal business logic.

1. The try-catch-finally Pattern

try {
    // Code that might throw an exception
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // Handle the specific exception
    System.out.println("Cannot divide by zero: " + e.getMessage());
} catch (Exception e) {
    // Catch-all for any other exception
    System.out.println("Unexpected error: " + e.getMessage());
} finally {
    // ALWAYS executes, whether exception occurred or not
    // Used for cleanup: closing files, database connections, etc.
    System.out.println("Cleanup complete.");
}

2. Exception Hierarchy

In Java, all exceptions inherit from Throwable:

• Error: Serious problems the application should NOT try to handle (OutOfMemoryError, StackOverflowError).
• Exception:
  • Checked Exceptions: Must be explicitly caught or declared with throws. Compile-time enforcement. Examples: IOException, SQLException.
  • Unchecked Exceptions (RuntimeException): Do not need to be declared. Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

3. Custom Exceptions

class InsufficientFundsException extends Exception {
    private double amount;
    public InsufficientFundsException(double amount) {
        super("Insufficient funds. Short by: $" + amount);
        this.amount = amount;
    }
    public double getAmount() { return amount; }
}

// Usage
void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance)
        throw new InsufficientFundsException(amount - balance);
    balance -= amount;
}

4. Best Practices

• Catch specific exceptions first, then general ones. Catching Exception too broadly hides bugs.
• Never swallow exceptions (empty catch blocks). At minimum, log the error.
• Use finally for cleanup, or better, use try-with-resources (Java) / RAII (C++) for automatic resource management.
• Throw early, catch late. Throw exceptions as close to the source of the error as possible. Catch them at a level where you can meaningfully handle them.
• Don't use exceptions for control flow. Exceptions are for exceptional situations, not for normal program logic.