Advanced Exception Handling

🛡️ Advanced Exception Handling in Java

Becoming a Master Problem-Solver

🎭 The Story of the Safety Net Factory

Imagine you work in a circus safety net factory. Your job? Making sure acrobats never hit the ground when they fall. Some falls you can predict (like during practice). Others surprise everyone (like when a trapeze breaks mid-show).

Java exceptions work the same way. Some problems we must prepare for. Others happen unexpectedly. Let’s learn how to catch them ALL like a pro!

🎯 Checked vs Unchecked Exceptions

The Two Types of Falls

Think of it like this:

Checked Exceptions: “Plan Ahead!”

Java says: “Hey! This might go wrong. Show me your backup plan!”

// Reading a file might fail
// Java FORCES you to handle it
public void readFile()
    throws IOException {
  FileReader fr =
    new FileReader("data.txt");
}

Why? Because files might not exist. Java wants you ready!

Unchecked Exceptions: “Oops Moments”

These happen because of programming mistakes. Java doesn’t force you to catch them.

// Dividing by zero - programmer error!
int result = 10 / 0;
// RuntimeException happens

Quick Memory Trick 🧠

• Checked = Things outside your control (files, networks)
• Unchecked = Bugs in YOUR code (null values, wrong math)

💥 Common Runtime Exceptions

These are the “oops moments” every programmer makes:

1. NullPointerException 👻

Talking to a ghost

String name = null;
name.length(); // BOOM! 💥
// Can't ask nothing for its length

2. ArrayIndexOutOfBoundsException 📦

Reaching for a box that isn’t there

int[] boxes = {1, 2, 3}; // 3 boxes
boxes[5]; // BOOM! 💥
// There is no 6th box!

3. ArithmeticException ➗

Math that breaks the universe

int answer = 100 / 0; // BOOM! 💥
// Can't divide by nothing!

4. ClassCastException 🎭

Wrong costume

Object obj = "Hello";
Integer num = (Integer) obj; // BOOM!
// String can't become Integer!

5. IllegalArgumentException 🚫

Wrong ingredient

// Method expects positive number
setAge(-5); // BOOM! 💥
// Age can't be negative!

📋 Common Checked Exceptions

These are predictable problems Java forces you to handle:

1. IOException 📁

File troubles

try {
  FileReader file =
    new FileReader("missing.txt");
} catch (IOException e) {
  System.out.println("No file!");
}

2. SQLException 🗄️

Database problems

try {
  connection.query("SELECT * ...");
} catch (SQLException e) {
  System.out.println("DB error!");
}

3. ClassNotFoundException 🔍

Missing puzzle piece

try {
  Class.forName("MissingClass");
} catch (ClassNotFoundException e) {
  System.out.println("Not found!");
}

4. InterruptedException ⏰

Someone woke you up early

try {
  Thread.sleep(1000);
} catch (InterruptedException e) {
  System.out.println("Wake up!");
}

🎨 Custom Exceptions

Building Your Own Safety Net

Sometimes, Java’s exceptions aren’t specific enough. Like if you’re building a bank app:

// Your own exception class!
public class InsufficientFundsException
    extends Exception {

  private double amount;

  public InsufficientFundsException(
      double amount) {
    super("Need quot; + amount + " more");
    this.amount = amount;
  }

  public double getAmount() {
    return amount;
  }
}

Using Your Custom Exception

public void withdraw(double money)
    throws InsufficientFundsException {

  if (money > balance) {
    throw new InsufficientFundsException(
      money - balance);
  }
  balance -= money;
}

Why Make Custom Exceptions?

• Clearer errors - “InsufficientFunds” beats “Exception”
• Extra info - Store HOW MUCH money was missing
• Better debugging - Find problems faster

🔐 try-with-resources

The Auto-Closer Magic

Remember when mom said “Close the door behind you”? Java has that too!

Old Way (easy to forget):

FileReader file = null;
try {
  file = new FileReader("data.txt");
  // read stuff
} finally {
  if (file != null) {
    file.close(); // Don't forget!
  }
}

New Way (Java closes for you!):

try (FileReader file =
     new FileReader("data.txt")) {
  // read stuff
} // Auto-closed! Magic! ✨

Multiple Resources? No Problem!

try (
  FileReader reader =
    new FileReader("in.txt");
  FileWriter writer =
    new FileWriter("out.txt")
) {
  // Both auto-close when done!
}

The Secret: AutoCloseable

Any class with close() method works:

public class MyResource
    implements AutoCloseable {

  public void close() {
    System.out.println("Cleaned up!");
  }
}

🔗 Exception Chaining

Telling the Full Story

Imagine a detective story. Each clue leads to another!

try {
  readFile();
} catch (IOException original) {
  // Wrap it with more context
  throw new DataLoadException(
    "Could not load user data",
    original  // Keep the original!
  );
}

Why Chain Exceptions?

DataLoadException: Could not load user data
  Caused by: IOException: File not found
    Caused by: FileNotFoundException: data.txt

Now you see the WHOLE story, not just the ending!

The Methods

// Get the original problem
Throwable cause = e.getCause();

// Set the cause later
e.initCause(originalException);

🎪 Multi-catch Block

One Net, Many Falls

Before Java 7:

try {
  riskyOperation();
} catch (IOException e) {
  logError(e);
} catch (SQLException e) {
  logError(e); // Same code! Boring!
}

After Java 7 (multi-catch):

try {
  riskyOperation();
} catch (IOException | SQLException e) {
  logError(e); // One block for both!
}

Rules for Multi-catch

1. Separate with | (pipe symbol)
2. Can’t be related - No parent-child exceptions
3. Variable is final - Can’t reassign e

// ❌ WRONG - IOException is parent
catch (IOException |
       FileNotFoundException e)

// ✅ RIGHT - Unrelated exceptions
catch (IOException |
       SQLException e)

⭐ Exception Best Practices

1. Be Specific, Not Lazy

// ❌ Bad - Too vague
catch (Exception e) { }

// ✅ Good - Specific
catch (FileNotFoundException e) { }

2. Never Swallow Silently

// ❌ Bad - Hiding problems
catch (Exception e) { }

// ✅ Good - At least log it!
catch (Exception e) {
  logger.error("Failed", e);
}

3. Clean Up Resources

// ✅ Use try-with-resources
try (Connection conn = getConn()) {
  // Always closes properly
}

4. Throw Early, Catch Late

// ✅ Check problems immediately
public void process(String data) {
  if (data == null) {
    throw new
      IllegalArgumentException("null!");
  }
  // Continue if valid...
}

5. Use Custom Exceptions Wisely

// ✅ When standard ones don't fit
throw new InvalidOrderException(
  "Order cannot be empty");

6. Include Helpful Messages

// ❌ Bad
throw new Exception("Error");

// ✅ Good
throw new Exception(
  "User ID " + id + " not found in DB");

7. Document Your Exceptions

/**
 * Withdraws money from account.
 * @throws InsufficientFundsException
 *         if balance too low
 */
public void withdraw(double amount)
    throws InsufficientFundsException {

🗺️ The Exception Family Tree

graph LR
    A["Throwable"] --> B["Error"]
    A --> C["Exception"]
    C --> D["RuntimeException"]
    C --> E["Checked Exceptions"]
    D --> F["NullPointerException"]
    D --> G["ArrayIndexOutOfBounds"]
    D --> H["ArithmeticException"]
    E --> I["IOException"]
    E --> J["SQLException"]
    B --> K["OutOfMemoryError"]

🎓 You Did It!

You now understand:

• ✅ Checked vs Unchecked - know what to catch
• ✅ Runtime Exceptions - common bugs to avoid
• ✅ Checked Exceptions - problems to plan for
• ✅ Custom Exceptions - make your own
• ✅ try-with-resources - auto-cleanup magic
• ✅ Exception Chaining - tell the full story
• ✅ Multi-catch - less code, same safety
• ✅ Best Practices - write like a pro

You’re now a Safety Net Master! 🏆

Every time your code handles an exception gracefully, you’re saving users from crashes and confusion. That’s a superpower worth having!

Remember: Good exception handling is like a good safety net. Users never see it work, but they’d definitely notice if it wasn’t there! 🎪