Exception Handling Basics

An exception is an event that disrupts the normal flow of a program's instructions, occurring during execution because of something abnormal — a missing file, an invalid array index, dividing by zero, or a null reference being used. Instead of letting the program crash immediately with no explanation, Java represents this event as an object and gives you a structured mechanism to detect it, react to it, and keep the rest of the program running safely.

Java forces you to deal with certain categories of exceptions at compile time. This is a deliberate design decision, not an accident: Sun Microsystems wanted large, long-lived Java programs to fail predictably and recoverably rather than silently or catastrophically. When a method can encounter a condition it cannot resolve on its own — a network call timing out, a file that doesn't exist — Java requires that this possibility be visible in the code, either by handling it or explicitly declaring it, so it can never be "forgotten" by whoever calls that method.

Why it matters

Real programs meet bad input, missing files and failed network calls every day. Without exception handling, the first such problem stops the whole program with a stack trace. With it, you decide what happens instead: report the problem, try something else, or carry on with the next item. That difference is what separates a script from software people can rely on.

Why Exceptions Exist

Without exceptions, error handling would rely on return codes (like -1 or null) that calling code could easily ignore. Exceptions separate the error-handling logic from the normal logic of a program: the code that detects a problem does not need to know how to fix it, and the code that knows how to recover does not need to be tangled into every line where a failure might occur.

• Detection — the JVM or your code identifies an abnormal condition and creates an exception object describing it.
• Propagation — if not handled immediately, the exception travels up the call stack, unwinding method calls until something catches it.
• Handling — a catch block (or the JVM itself, as a last resort) processes the exception, potentially recovering, logging, or terminating gracefully.

What Happens Without Handling

If an exception is never caught anywhere in the call stack, it reaches the JVM's default handler, which prints a stack trace to the console (showing the exception type, its message, and the exact sequence of method calls that led to it) and terminates that thread. This is why unhandled exceptions in a program's main method cause it to stop and print a trace instead of continuing.

Example

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

        try {
            System.out.println(numbers[5]); // invalid index
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        System.out.println("Program continues normally.");
    }
}

Caught: Index 5 out of bounds for length 3
Program continues normally.

Exercise

Write divide so that dividing by zero does not crash the program. When the divisor is zero it should print a message and return 0, and the program should carry on to its last line.

Expected output: 5, Cannot divide by zero, 0, Done

public class SafeDivide {

    static int divide(int a, int b) {
        // TODO: return a / b, but catch ArithmeticException,
        // print "Cannot divide by zero" and return 0
        return a / b;
    }

    public static void main(String[] args) {
        System.out.println(divide(10, 2));
        System.out.println(divide(10, 0));
        System.out.println("Done");
    }
}

public class SafeDivide {

    static int divide(int a, int b) {
        try {
            return a / b;
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
            return 0;
        }
    }

    public static void main(String[] args) {
        System.out.println(divide(10, 2));
        System.out.println(divide(10, 0));
        System.out.println("Done");
    }
}

Quick quiz

Interview questions