🎯 Java Exception Handling: Complete Guide

Quote

“Exception handling is not about preventing errors, but about managing them gracefully”

🏗️ What is Exception Handling?

Exception handling is fundamental to building reliable, robust applications. It enables graceful error recovery, prevents application crashes, and provides meaningful error information.

🎯 Core Concepts

Note

An exception is an event that disrupts the normal flow of the program.

• An exception is an event that disrupts the normal flow of the program
• It is an object that describes an error condition
• Exception handling allows programs to recover gracefully from errors

---

❗ Types of Exceptions

Tip

Understanding the difference between checked and unchecked exceptions is crucial for proper exception handling.

Exception Categories

Category	Description	Examples
Checked	Checked at compile time	IOException, SQLException
Unchecked	Checked at runtime	NullPointerException, ArrayIndexOutOfBoundsException
Errors	Serious issues, not recoverable	OutOfMemoryError, StackOverflowError

Key Differences

Feature	Checked	Unchecked
Compile-time check	✅ Yes	❌ No
Must handle	Yes (try-catch or throws)	Optional
Typical use	File I/O, DB access, Network	Logic bugs, NullPointer
Superclass	Exception	RuntimeException
Recovery possible	Often yes	Usually no

---

📊 Java Exception Hierarchy

Note

All exceptions in Java inherit from Throwable, which has two main branches: Error and Exception.

java.lang.Throwable
├── Error (Unchecked, JVM-level)
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   ├── VirtualMachineError
│   └── LinkageError
└── Exception
    ├── Checked Exception (must handle)
    │   ├── IOException
    │   ├── SQLException
    │   ├── ClassNotFoundException
    └── Unchecked Exception (RuntimeException & subclasses)
        ├── NullPointerException
        ├── IllegalArgumentException
        ├── ArrayIndexOutOfBoundsException
        ├── ClassCastException
        ├── NumberFormatException
        └── ConcurrentModificationException

🔍 Key Differences

Type	When Thrown	Must Handle	Example
Error	JVM/system level	❌ No	OutOfMemoryError
Checked Exception	Application logic	✅ Yes	IOException
Unchecked Exception	Runtime logic errors	❌ No	NullPointerException

---

🔄 try-catch-finally Block

Note

The try-catch-finally block is the fundamental mechanism for handling exceptions in Java.

Basic Structure

Use try to wrap code that might throw exceptions.

try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
} finally {
    System.out.println("Always executes");
}

Components Explained

• try: Monitors the block for exceptions
• catch: Handles specific exception types
• finally: Always executes, used for cleanup (like closing files)

---

🔄 Multiple catch Blocks

Tip

You can handle different exceptions separately for more specific error handling.

Multiple Exception Handling

try {
    int[] arr = new int[5];
    System.out.println(arr[10]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index out of range!");
} catch (Exception e) {
    System.out.println("Some error occurred");
}

Important Rules

Caution

Order catch blocks from most specific to most general. More specific exceptions must come first.

public class MultipleCatchExample {
    public static void process(String input) {
        try {
            int number = Integer.parseInt(input);
            int result = 100 / number;
            System.out.println("Result: " + result);
        } catch (NumberFormatException e) {
            System.err.println("Invalid number format: " + input);
        } catch (ArithmeticException e) {
            System.err.println("Division by zero");
        } catch (Exception e) {
            System.err.println("Unexpected error: " + e.getMessage());
        }
    }

    // Java 7+ multi-catch
    public static void multiCatch(String input) {
        try {
            int number = Integer.parseInt(input);
            int result = 100 / number;
            System.out.println("Result: " + result);
        } catch (NumberFormatException | ArithmeticException e) {
            System.err.println("Input error: " + e.getMessage());
        }
    }
}

---

🔐 The throws Keyword

Note

The throws keyword is used when a method declares it might throw an exception.

Key Points

• Used when a method declares it might throw an exception
• Moves responsibility to the caller
• Caller must handle the exception or declare it further

Example

public class ThrowsExample {
    public void readFile() throws IOException {
        FileReader fr = new FileReader("file.txt");
        // File operations
    }

    public void processFile() throws IOException, SQLException {
        readFile(); // This method throws IOException
        // Database operations that might throw SQLException
    }

    // Caller must handle exceptions
    public static void main(String[] args) {
        ThrowsExample example = new ThrowsExample();
        try {
            example.processFile();
        } catch (IOException | SQLException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

---

🚫 The throw Keyword

Danger

The throw keyword is used to explicitly throw an exception.

Usage

public class ThrowExample {
    public static void validateAge(int age) {
        if (age < 18) {
            throw new ArithmeticException("Not eligible to vote");
        }
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        System.out.println("Valid age: " + age);
    }

    public static void main(String[] args) {
        try {
            validateAge(15); // Will throw exception
        } catch (ArithmeticException e) {
            System.err.println("Validation failed: " + e.getMessage());
        }
    }
}

Custom Exception with throw

public class CustomValidation {
    public static void validateEmail(String email) {
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email format: " + email);
        }
        System.out.println("Valid email: " + email);
    }
}

---

🏗️ Custom Exceptions

Tip

You can create your own exceptions by extending Exception or RuntimeException.

Custom Exception Class

class AgeException extends Exception {
    AgeException(String msg) {
        super(msg);
    }
}

// Usage
public class CustomExceptionExample {
    public static void validateAge(int age) throws AgeException {
        if (age < 0) {
            throw new AgeException("Invalid Age: " + age);
        }
        if (age > 150) {
            throw new AgeException("Age seems unrealistic: " + age);
        }
        System.out.println("Valid age: " + age);
    }

    public static void main(String[] args) {
        try {
            validateAge(-5); // Will throw AgeException
        } catch (AgeException e) {
            System.err.println("Age validation failed: " + e.getMessage());
        }
    }
}

---

📚 Common Built-in Exceptions

Tip

Understanding common exceptions helps in writing better error handling code.

Exception Reference Table

Exception	Description	Example
NullPointerException	Accessing a null object reference	String str = null; str.length();
ArrayIndexOutOfBoundsException	Invalid array index	int[] arr = new int[5]; arr[10];
ClassNotFoundException	Class not found at runtime	Class.forName("NonExistentClass");
IllegalArgumentException	Invalid method argument	Integer.parseInt("abc");
NumberFormatException	Invalid conversion	Integer.parseInt("abc");
ArithmeticException	Mathematical error	int result = 10 / 0;
ClassCastException	Invalid type casting	Object obj = "String"; Integer num = (Integer) obj;

✅ Best Practices

Caution

Following best practices ensures robust and maintainable exception handling code.

Essential Guidelines

• Catch only specific exceptions - avoid catching generic Exception
• Always clean up with finally or try-with-resources
• Avoid empty catch blocks - always handle or log exceptions
• Don’t use exceptions for flow control - they’re expensive
• Log exceptions properly with context information
• Rethrow exceptions when appropriate to maintain the call stack