Exceptions & Error Handling in Java

Exception handling is a cornerstone of robust and maintainable Java applications. While garbage collection deals with memory safety, exception handling deals with program stability under error conditions. Understanding how Java models exceptions, how to use them properly, and how to avoid common pitfalls is critical for every developer.

This post is a comprehensive guide (~5000 words) covering the following:

1. Fundamentals of Exceptions
2. Exception Hierarchy
3. Try-Catch-Finally
4. Throwing and Defining Exceptions
5. Best Practices
6. Advanced Topics
7. Common Memory Leak Patterns with Exceptions
8. Interview Preparation

---

1. Fundamentals of Exceptions

What is an Exception?

An exception is an event that disrupts the normal flow of execution. In Java, exceptions are objects that represent these abnormal events. Instead of crashing the entire program, exceptions allow errors to be caught and handled gracefully.

Example:

public class DivisionExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = a / b; // Division by zero
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Error: / by zero

Without the try-catch block, the program would terminate abnormally.

Types of Errors

• Syntax Errors: Found at compile time, e.g., missing semicolons.
• Logical Errors: Wrong results due to incorrect logic.
• Runtime Errors (Exceptions): Errors that occur during execution, e.g., null pointer access.

---

2. Exception Hierarchy

All exceptions in Java inherit from the class Throwable.

Throwable
 ├── Error
 └── Exception
      ├── RuntimeException
      └── (Other checked exceptions)

Errors

• Represent serious problems the application should not handle.
• Examples: OutOfMemoryError, StackOverflowError.

Checked Exceptions

• Must be either caught or declared with throws.
• Examples: IOException, SQLException.

Unchecked Exceptions (Runtime Exceptions)

• Do not need explicit handling.
• Examples: NullPointerException, ArrayIndexOutOfBoundsException.

Key Difference:

• Checked exceptions → recoverable conditions.
• Unchecked exceptions → programming mistakes.

---

3. Try-Catch-Finally

Basic Syntax

try {
    // Risky code
} catch (ExceptionType e) {
    // Handle exception
} finally {
    // Cleanup code, always executes
}

Multiple Catch Blocks

try {
    int[] arr = new int[2];
    arr[5] = 100; // Out of bounds
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index issue: " + e.getMessage());
} catch (Exception e) {
    System.out.println("General error: " + e.getMessage());
}

Multi-Catch (Java 7+)

try {
    String text = null;
    System.out.println(text.length());
} catch (NullPointerException | IllegalArgumentException e) {
    System.out.println("Error: " + e);
}

Finally Block

Ensures cleanup regardless of exceptions.

FileReader reader = null;
try {
    reader = new FileReader("data.txt");
    // Work with file
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try { reader.close(); } catch (IOException ignored) {}
    }
}

---

4. Throwing and Defining Exceptions

Using throw

public void withdraw(double amount) {
    if (amount > balance) {
        throw new IllegalArgumentException("Insufficient balance");
    }
    balance -= amount;
}

Using throws

public void readFile(String path) throws IOException {
    FileReader fr = new FileReader(path);
    fr.read();
}

Creating Custom Exceptions

class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

class BankAccount {
    private double balance;

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Balance too low");
        }
        balance -= amount;
    }
}

---

5. Best Practices

1. Don’t swallow exceptions:

try {
    riskyOperation();
} catch (Exception e) {
    // Bad: nothing logged
}

2. Log meaningful messages.

3. Use checked exceptions for recoverable conditions, runtime exceptions for programming errors.

4. Avoid overusing checked exceptions → leads to clutter.

5. Fail fast: detect errors early.

6. Translate exceptions into meaningful domain exceptions.

---

6. Advanced Topics

Exception Translation

try {
    dbCall();
} catch (SQLException e) {
    throw new DataAccessException("Database error", e);
}

Exception Chaining

Preserves the cause.

try {
    parseConfig();
} catch (IOException e) {
    throw new RuntimeException("Failed to parse config", e);
}

Suppressed Exceptions (Java 7+)

try (FileReader fr = new FileReader("a.txt")) {
    // Auto-closed
} catch (IOException e) {
    e.printStackTrace();
}

Performance Considerations

• Exceptions are expensive to create and throw.
• Don’t use them for control flow.

---

7. Memory Leaks & Exceptions

• Exception objects themselves are GCed when unreachable.
• But improper handling can create leaks:
  • Holding references in static fields.
  • Retaining stack traces unnecessarily.

Example:

List<Exception> log = new ArrayList<>();
try {
    riskyOp();
} catch (Exception e) {
    log.add(e); // Leaks stack traces if unbounded
}

---

8. Interview Focus

Common Questions

1. Difference between checked and unchecked exceptions?
2. What happens if finally has return?
3. Difference between throw and throws?
4. Why not use exceptions for flow control?
5. Difference between final, finally, and finalize()?

Example Answer (OOM Troubleshooting)

• Gather heap dump.
• Review logs.
• Check for unintentional retention.
• Fix code or increase heap.

---

Summary

• Java exceptions provide structured error handling.
• Hierarchy: Throwable → Error / Exception → RuntimeException.
• Checked vs unchecked → recoverable vs programming mistakes.
• Best practices: log, translate, chain, don’t swallow.
• Advanced tools: try-with-resources, suppressed exceptions, Cleaner API.
• Interview tip: GC doesn’t prevent leaks; exceptions still need careful handling.

👉 By mastering exception handling, you write safer, cleaner, production-ready Java code.