Exception Handling Basics

Exception Handling Basics in Java

🎭 The Story of the Safety Net

Imagine you’re a circus performer walking on a tightrope. What’s below you? A safety net! If you slip and fall, the net catches you. You don’t crash to the ground.

Exception Handling in Java is exactly like that safety net.

When your program runs, sometimes things go wrong. A file might be missing. A number might be divided by zero. A network connection might fail. Without a safety net, your program crashes. With exception handling, your program recovers gracefully.

🌟 Exception Fundamentals

What is an Exception?

An exception is an unexpected problem that happens while your program runs.

Think of it like this:

• You’re making a sandwich (your program is running)
• You reach for bread, but the jar is empty! (an exception occurs)
• Without handling: You panic and give up (program crashes)
• With handling: You calmly go buy more bread (program recovers)

Real Examples of Exceptions

Errors vs Exceptions

Problems in Java
      │
      ├── Errors (serious, can't fix)
      │     └── Computer ran out of memory
      │
      └── Exceptions (can handle!)
            ├── Checked (must handle)
            └── Unchecked (optional)

Errors = House on fire. Call firefighters. Exceptions = Spilled milk. Clean it up yourself.

🎯 The try-catch Block

Your First Safety Net

The try-catch block is your primary tool. It says:

• try = “Attempt this risky code”
• catch = “If something goes wrong, do this instead”

Simple Example

try {
    int result = 10 / 0;  // Risky!
    System.out.println(result);
} catch (ArithmeticException e) {
    System.out.println("Oops! Can't divide by zero!");
}

What happens:

1. Java tries to divide 10 by 0
2. That’s impossible! Exception occurs!
3. Java catches the problem
4. Instead of crashing, it prints our friendly message

Real-World Analogy

try {
    Walk across the room blindfolded
} catch (BumpIntoChairException e) {
    Say "Found a chair!" and walk around it
}

Catching Multiple Exceptions

Sometimes different things can go wrong. Catch them separately!

try {
    int[] numbers = {1, 2, 3};
    int x = numbers[10];     // Problem 1?
    int y = 10 / 0;          // Problem 2?
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Array too small!");
} catch (ArithmeticException e) {
    System.out.println("Math error!");
}

The Exception Object

When you catch an exception, you get information about what went wrong:

catch (Exception e) {
    e.getMessage();      // Short description
    e.printStackTrace(); // Full error details
}

🔒 The finally Block

The “Always Do This” Section

Sometimes you need to do something no matter what happens. Enter finally.

Analogy: When you borrow a library book:

• try = Read the book
• catch = Handle if pages are torn
• finally = ALWAYS return the book!

Example

try {
    // Open a file
    // Read from file
} catch (Exception e) {
    System.out.println("Error reading file!");
} finally {
    // Close the file - ALWAYS happens!
    System.out.println("Cleaning up...");
}

When Does finally Run?

finally is unstoppable! (almost)

The Complete Pattern

try {
    // 1. Risky code here
} catch (SpecificException e) {
    // 2. Handle specific problem
} catch (Exception e) {
    // 3. Handle any other problem
} finally {
    // 4. Always clean up
}

🎪 The throw Keyword

Creating Your Own Exceptions

Sometimes YOU want to signal a problem. Use throw!

Analogy: You’re a referee. When a player breaks a rule, you blow your whistle and throw a flag!

public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException(
            "Age cannot be negative!"
        );
    }
    this.age = age;
}

How throw Works

Your Code          Java Runtime
    │                    │
    │  throw Exception   │
    │  ──────────────►   │
    │                    │ Stops normal flow
    │                    │ Looks for catch
    │    ◄────────────   │
    │  (caught or crash) │

Common Throw Patterns

Validation:

if (name == null) {
    throw new NullPointerException(
        "Name cannot be null"
    );
}

Business Rules:

if (balance < amount) {
    throw new InsufficientFundsException(
        "Not enough money!"
    );
}

📋 The throws Keyword

Passing the Problem Up

Sometimes you don’t want to handle an exception yourself. You want to warn others: “Hey, this method might cause problems!”

Analogy:

• throw = Actually throwing a ball
• throws = Putting up a sign: “Warning: Balls may fly here!”

Syntax

public void readFile(String path)
        throws FileNotFoundException {
    // Code that might fail
    FileReader file = new FileReader(path);
}

throw vs throws

Multiple throws

public void riskyMethod()
        throws IOException,
               SQLException,
               ParseException {
    // Multiple things could go wrong
}

Who Must Handle It?

When you use throws, the caller must either:

1. Catch the exception, OR
2. Declare throws themselves

// Option 1: Catch it
public void caller() {
    try {
        riskyMethod();
    } catch (IOException e) {
        // Handle it
    }
}

// Option 2: Pass it up
public void caller() throws IOException {
    riskyMethod();
}

🌳 Exception Hierarchy

The Family Tree

All exceptions in Java belong to a family tree:

graph TD
    A["Throwable"] --> B["Error"]
    A --> C["Exception"]
    B --> D["OutOfMemoryError"]
    B --> E["StackOverflowError"]
    C --> F["RuntimeException"]
    C --> G["IOException"]
    C --> H["SQLException"]
    F --> I["NullPointerException"]
    F --> J["ArithmeticException"]
    F --> K["ArrayIndexOutOfBoundsException"]

Understanding the Levels

Level 1: Throwable

• The grandparent of all problems
• Everything extends this

Level 2: Error vs Exception

• Error = Serious. System-level. Don’t catch.
• Exception = Your problems. You CAN handle.

Level 3: Checked vs Unchecked

Why Does This Matter?

Catch order matters! Catch specific exceptions first:

// ✅ CORRECT - Specific first
catch (FileNotFoundException e) { }
catch (IOException e) { }

// ❌ WRONG - General catches everything
catch (IOException e) { }
catch (FileNotFoundException e) { }  // Never reached!

Quick Reference

Unchecked (RuntimeException)
├── NullPointerException
├── ArithmeticException
├── IllegalArgumentException
└── ArrayIndexOutOfBoundsException

Checked (must handle or declare)
├── IOException
├── FileNotFoundException
├── SQLException
└── ParseException

🎯 Putting It All Together

The Complete Picture

public class SafeCalculator {

    public double divide(int a, int b)
            throws IllegalArgumentException {

        // THROW: Create exception if invalid
        if (b == 0) {
            throw new IllegalArgumentException(
                "Cannot divide by zero!"
            );
        }

        return (double) a / b;
    }

    public void calculate() {
        // TRY: Attempt risky operation
        try {
            double result = divide(10, 0);
            System.out.println("Result: " + result);

        // CATCH: Handle the problem
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " +
                e.getMessage());

        // FINALLY: Always clean up
        } finally {
            System.out.println("Calculation done!");
        }
    }
}

💡 Remember This!

1. try-catch = Your safety net for risky code
2. finally = “Always do this” (cleanup crew)
3. throw = Create and throw an exception
4. throws = Warning label on methods
5. Hierarchy = Catch specific before general

You’re now ready to write code that handles problems gracefully instead of crashing! 🎉