Lesson 12 • Expert
Exception Handling
Build robust applications that handle errors gracefully — because in the real world, things go wrong, and your code needs a plan.
📚 Before You Start
You should be comfortable with:
- Methods (Lesson 6) — calling and returning values
- OOP (Lesson 9) — classes, constructors, inheritance
- Control Flow (Lesson 4) — if/else statements
What You'll Learn
- ✅ What exceptions are and the exception hierarchy
- ✅ try-catch-finally blocks and how the flow works
- ✅ Checked vs unchecked exceptions (and when each applies)
- ✅ Throwing exceptions with
throwand declaring withthrows - ✅ Creating meaningful custom exception classes
- ✅ Try-with-resources for automatic cleanup (Java 7+)
1️⃣ How Exceptions Work
Real-world analogy: Exceptions are like emergency procedures. When a fire alarm goes off, you don't freeze — you follow a protocol. Similarly, try-catch lets your program detect problems and respond gracefully instead of crashing.
try {
// Risky code that might fail
int result = 10 / 0;
System.out.println("This never prints!");
} catch (ArithmeticException e) {
// Handle the specific error
System.out.println("Cannot divide by zero: " + e.getMessage());
} finally {
// ALWAYS runs — use for cleanup
System.out.println("Cleanup complete");
}2️⃣ The Exception Hierarchy
Understanding this tree is essential — it determines what you must catch vs what's optional:
Throwable
├── Error (DON'T catch — JVM problems)
│ ├── OutOfMemoryError
│ └── StackOverflowError
└── Exception
├── IOException (CHECKED — must handle)
├── SQLException (CHECKED — must handle)
└── RuntimeException (UNCHECKED — optional to catch)
├── NullPointerException
├── ArrayIndexOutOfBoundsException
├── ArithmeticException
└── IllegalArgumentExceptionChecked exceptions: The compiler forces you to handle them. These represent recoverable problems.
Unchecked exceptions: Extend RuntimeException. Usually indicate programming bugs.
Try It: Basic Exception Handling
See how try-catch-finally controls program flow during errors
// 💡 Try modifying this code and see what happens!
// Basic Exception Handling (Simulated)
console.log("=== Try-Catch-Finally Flow ===\n");
// 1. Basic flow
console.log("1. Normal flow:");
try {
console.log(" Try block starts");
let result = 10 / 2;
console.log(" Result: " + result);
} catch (error) {
console.log(" Catch: " + error.message);
} finally {
console.log(" Finally runs (always)");
}
// 2. Error flow
console.log("\n2. Error flow:");
try {
console.log(" T
...3️⃣ Throwing & Declaring Exceptions
throw creates and throws an exception. throws declares that a method might throw one.
// Throwing — validate input and reject bad data
public void setAge(int age) {
if (age < 0 || age > 150) {
throw new IllegalArgumentException("Age must be 0-150, got: " + age);
}
this.age = age;
}
// Custom exception for domain-specific errors
public class InsufficientFundsException extends Exception {
private double deficit;
public InsufficientFundsException(double deficit) {
super("Insufficient funds: need $" + deficit + " more");
this.deficit = deficit;
}
public double getDeficit() { return deficit; }
}4️⃣ Try-With-Resources (Java 7+)
Analogy: It's like a self-closing door — you walk through, and it automatically closes behind you. No need to remember to close files or connections manually.
// OLD way — error-prone, verbose
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader("data.txt"));
String line = reader.readLine();
} finally {
if (reader != null) reader.close(); // messy!
}
// MODERN way — clean and safe!
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
String line = reader.readLine();
// reader.close() called AUTOMATICALLY!
} catch (IOException e) {
System.out.println("File error: " + e.getMessage());
}Try It: Custom Exception Classes
Build a bank account system with domain-specific exceptions
// 💡 Try modifying this code and see what happens!
// Custom Exceptions — Bank Account (Simulated)
console.log("=== Custom Exceptions ===\n");
class InsufficientFundsError extends Error {
constructor(balance, amount) {
super("Need $" + (amount - balance).toFixed(2) + " more");
this.name = "InsufficientFundsError";
this.balance = balance;
this.attempted = amount;
}
}
class AccountFrozenError extends Error {
constructor(reason) {
super("Accoun
...5️⃣ Common Beginner Mistakes
❌ Mistake 1: Catching Exception too broadly
// BAD — hides ALL errors including bugs!
catch (Exception e) { System.out.println("Something happened"); }
// GOOD — catch specific exceptions first
catch (FileNotFoundException e) { /* handle missing file */ }
catch (IOException e) { /* handle other I/O issues */ }❌ Mistake 2: Empty catch blocks (swallowing exceptions)
// TERRIBLE — error silently disappears!
catch (Exception e) { }
// At minimum, log it
catch (Exception e) { logger.error("Failed to process", e); }❌ Mistake 3: Using exceptions for flow control
Don't use try-catch as an if-else replacement. Exceptions are for exceptional situations — they're 100x slower than normal conditionals.
6️⃣ Pro Tips
💡 Catch the most specific exception type first (child before parent).
💡 Include context in exception messages: what failed and why.
💡 Use try-with-resources for anything that implements AutoCloseable.
💡 Create custom exceptions for your domain: InsufficientFundsException is clearer than RuntimeException.
💡 Log exceptions at the point of handling, not at every layer they pass through.
Try It: Resource Cleanup & Form Validation
Practice try-with-resources patterns and input validation
// 💡 Try modifying this code and see what happens!
// Resource Cleanup & Validation (Simulated)
console.log("=== Resource Cleanup ===\n");
// Simulating try-with-resources
class DatabaseConnection {
constructor(name) { this.name = name; this.open = true; console.log(" 📂 Opened " + name); }
query(sql) {
if (!this.open) throw new Error("Connection closed!");
console.log(" 📋 Running: " + sql);
return [{id: 1, name: "Alice"}, {id: 2, name: "Bob"}];
}
clo
...📋 Quick Reference
| Keyword | Syntax | Purpose |
|---|---|---|
| try | try { risky code } | Wrap risky code |
| catch | catch (IOException e) | Handle specific error |
| finally | finally { cleanup } | Always runs (cleanup) |
| throw | throw new Exception(msg) | Create & throw error |
| throws | void read() throws IOException | Declare checked exception |
| try-with | try (var r = new R()) | Auto-close resources |
🎉 Lesson Complete!
You can now write robust Java code that handles errors gracefully — from basic try-catch to custom exceptions to try-with-resources for automatic cleanup.
Next up: Collections Framework — work with ArrayList, HashMap, HashSet, and more powerful data structures.
Sign up for free to track which lessons you've completed and get learning reminders.