Exception Handling

What is an Exception?

An exception is an abnormal condition that disrupts the normal flow of a program at runtime. Java provides a robust mechanism to handle such conditions gracefully.

Exception Hierarchy

All exceptions in Java are subclasses of Throwable:

java.lang.Object
  └── java.lang.Throwable
        ├── java.lang.Error          (JVM errors — do NOT handle)
        │     ├── OutOfMemoryError
        │     ├── StackOverflowError
        │     └── VirtualMachineError
        └── java.lang.Exception      (handle these)
              ├── Checked Exceptions (compile-time)
              │     ├── IOException
              │     ├── SQLException
              │     └── FileNotFoundException
              └── RuntimeException   (unchecked)
                    ├── ArithmeticException
                    ├── NullPointerException
                    ├── ArrayIndexOutOfBoundsException
                    ├── ClassCastException
                    └── NumberFormatException

try-catch-finally

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};

        try {
            int result = arr[0] / 0; // ArithmeticException
            arr[5] = 99;               // ArrayIndexOutOfBoundsException
        } catch (ArithmeticException e) {
            System.out.println("Math error: " + e.getMessage());
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array error: " + e.getMessage());
        } finally {
            System.out.println("Finally always executes!");
        }
    }
}

throw & throws

// Using 'throw' to manually throw an exception
static void validateAge(int age) {
    if (age < 18)
        throw new IllegalArgumentException("Age must be 18 or above: " + age);
    System.out.println("Valid age: " + age);
}

// Using 'throws' to delegate handling to caller
static void readFile(String path) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(path));
    System.out.println(br.readLine());
    br.close();
}

public static void main(String[] args) {
    try {
        validateAge(15);
        readFile("data.txt");
    } catch (IllegalArgumentException | IOException e) {
        System.out.println("Error: " + e.getMessage());
    }
}

Multiple catch Blocks

Multiple catch blocks allow handling different exception types separately. Catch order matters — more specific exceptions must come before general ones.

try {
    String s = null;
    s.length();             // NullPointerException
    int x = Integer.parseInt("abc"); // NumberFormatException
} catch (NullPointerException e) {
    System.out.println("Null: " + e);
} catch (NumberFormatException e) {
    System.out.println("Format: " + e);
} catch (Exception e) {
    // catches any other Exception — must be LAST
    System.out.println("General: " + e);
}

Nested try

try {
    System.out.println("Outer try");
    try {
        int x = 10 / 0;  // handled in inner catch
    } catch (ArithmeticException e) {
        System.out.println("Inner catch: " + e.getMessage());
        throw new RuntimeException("Re-thrown"); // escalate
    }
} catch (RuntimeException e) {
    System.out.println("Outer catch: " + e.getMessage());
}

User-defined Exceptions

Create custom exceptions by extending Exception (checked) or RuntimeException (unchecked).

// Custom checked exception
class InsufficientFundsException extends Exception {
    private double amount;
    InsufficientFundsException(double a) {
        super("Insufficient funds. Need: ₹" + a);
        amount = a;
    }
    double getAmount() { return amount; }
}

class BankAccount {
    double balance = 1000;

    void withdraw(double amt) throws InsufficientFundsException {
        if (amt > balance)
            throw new InsufficientFundsException(amt - balance);
        balance -= amt;
    }
}

Common Built-in Exceptions