Exception

You walk up to an ATM, put in your card and ask for 2,000 rupees. Your account holds 1,500. The machine does not freeze, and it does not hand out money it does not have. It shows a clear message, returns your card and gets ready for the next person. Something went wrong, and the machine handled it calmly.

Java programs meet surprises like this all the time: a number typed with a letter O instead of a zero, a network that drops, a value that should never be zero. Java reports each surprise as an exception. In this guide you will learn what an exception is, how the family of exception classes is arranged, the difference between checked and unchecked exceptions, and what really happens inside the call stack when one is thrown.

What is an Exception?

Two ideas hide in that sentence. First, an exception is an event: normal execution stops at that line. Second, it is also an ordinary object, an instance of some class that extends Throwable. Because it is an object, you can catch it, ask for its message and decide what to do next.

When your code creates such an object and hands it to the JVM, we say the code throws the exception. When some other code receives it and deals with it, we say that code catches it.

Why is Exception handling used?

Without exceptions, every method would have to return special error codes, and every caller would have to check them. Programmers forget those checks, and bugs slip through quietly.

• Errors cannot be ignored silently. An exception that nobody catches stops the thread and prints a report, so problems surface early.
• Clean main logic. The normal path stays readable, and error handling lives in its own block.
• Rich information. The object carries a type, a message and a stack trace that points to the exact line.
• Handling at the right level. A low-level method can report the problem, and a higher-level method that knows what to tell the user can handle it.
• Programs keep running. A caught exception lets the program recover, like the ATM serving the next customer.

Real-Life Example

Picture the chain of people behind that ATM request. The screen software asks the cash unit for notes. The cash unit asks the bank's account service for the balance. The account service notices the balance is too low.

The account service cannot fix this. It is not its job to talk to the customer. So it raises a flag, a written note saying "need 2,000, have 1,500", and passes it back up. The cash unit has no plan for that note either, so it stops what it was doing and passes it up again. Finally the screen software, which knows how to talk to customers, reads the note and shows a friendly message.

That note is the exception object. Raising the flag is throw. Each worker that passes it along without a plan is a method that does not catch it. The screen software is the method with a catch block.

java
// throwing an exception
throw new IllegalStateException("message");

// declaring a checked exception a method may throw
void verify(String card) throws CardBlockedException {
    // ...
}

// catching an exception
try {
    // code that might throw
} catch (IllegalStateException e) {
    String text = e.getMessage();
}

How Exceptions Work

The Throwable family

Every exception class sits in one family tree with Throwable at the top.

text
Throwable
 |
 +-- Error  (unchecked)
 |    +-- OutOfMemoryError
 |    +-- StackOverflowError
 |
 +-- Exception  (checked)
      +-- IOException
      +-- InterruptedException
      +-- RuntimeException
          (unchecked)
          +-- ArithmeticException
          +-- NullPointerException

Error means the JVM itself is in serious trouble, such as running out of memory, and normal code should not try to catch it. Exception covers problems a program can reasonably handle. Everything under Exception is checked by the compiler, except the RuntimeException branch, whose members are unchecked. Anything under Error is unchecked too.

Stack unwinding

Each method call gets a frame on the call stack. When an exception is thrown, the JVM looks for a matching catch in the current frame. If there is none, it removes that frame and tries the caller.

text
+--------------+
| checkBalance | <- thrown here
+--------------+    no catch: pop
| dispense     |    no catch: pop
+--------------+
| startSession |    no catch: pop
+--------------+
| main         | <- catch found
+--------------+

This popping is called stack unwinding. The leftover statements in each popped method never run. If the JVM pops every frame, even main, and finds no handler, the thread dies and the default handler prints the stack trace. That is the "crash" beginners see.

java
public class AtmUnwind {
    static int balance = 1500;

    static void checkBalance(int amount) {
        System.out.println("  in checkBalance");
        if (amount > balance) {
            throw new IllegalStateException(
                    "need " + amount + ", have " + balance);
        }
        System.out.println("  balance ok");
    }

    static void dispense(int amount) {
        System.out.println(" in dispense");
        checkBalance(amount);
        System.out.println(" notes counted");
    }

    static void startSession(int amount) {
        System.out.println("in startSession");
        dispense(amount);
        System.out.println("session closed");
    }

    public static void main(String[] args) {
        try {
            startSession(2000);
        } catch (IllegalStateException e) {
            System.out.println("caught in main");
            System.out.println("type: "
                    + e.getClass().getSimpleName());
            System.out.println("msg : " + e.getMessage());
            System.out.println("stack, top first:");
            for (StackTraceElement f : e.getStackTrace()) {
                System.out.println("  " + f.getMethodName());
            }
        }
        System.out.println("ATM ready for next card");
    }
}

text
in startSession
 in dispense
  in checkBalance
caught in main
type: IllegalStateException
msg : need 2000, have 1500
stack, top first:
  checkBalance
  dispense
  startSession
  main
ATM ready for next card

java
class CardBlockedException extends Exception {
    CardBlockedException(String message) {
        super(message);
    }
}

public class CardCheck {
    static void verifyCard(String card) throws CardBlockedException {
        if (card.endsWith("0000")) {
            throw new CardBlockedException("card " + card + " blocked");
        }
        System.out.println("card " + card + " ok");
    }

    static int readAmount(String typed) {
        return Integer.parseInt(typed);
    }

    public static void main(String[] args) {
        String[] cards = {"4111-2222", "5500-0000"};
        for (String card : cards) {
            try {
                verifyCard(card);
            } catch (CardBlockedException e) {
                System.out.println("checked: " + e.getMessage());
            }
        }

        String[] typed = {"500", "5OO"};
        for (String t : typed) {
            try {
                System.out.println("amount " + readAmount(t));
            } catch (NumberFormatException e) {
                System.out.println("unchecked: "
                        + e.getClass().getSimpleName());
            }
        }
    }
}

text
card 4111-2222 ok
checked: card 5500-0000 blocked
amount 500
unchecked: NumberFormatException

java
import java.io.IOException;

public class FaultSorter {
    static String family(Throwable t) {
        if (t instanceof Error) {
            return "Error";
        } else if (t instanceof RuntimeException) {
            return "unchecked";
        } else {
            return "checked";
        }
    }

    public static void main(String[] args) {
        Throwable[] faults = {
            new ArithmeticException("split by 0"),
            new IOException("receipt printer offline"),
            new StackOverflowError(),
            new IllegalArgumentException("bad PIN"),
            new InterruptedException("session stopped")
        };
        for (Throwable t : faults) {
            String name = t.getClass().getSimpleName();
            System.out.println(name);
            System.out.println("  = " + family(t));
        }
    }
}

text
ArithmeticException
  = unchecked
IOException
  = checked
StackOverflowError
  = Error
IllegalArgumentException
  = unchecked
InterruptedException
  = checked

Checked vs Unchecked Exceptions

A good rule: use checked exceptions for problems a caller can realistically recover from, and unchecked ones for programming mistakes.

Common Mistakes

• Catching `Exception` everywhere. A broad catch also traps bugs such as NullPointerException that you would rather see and fix.
• Catching `Error` or `Throwable`. An OutOfMemoryError cannot be fixed by your code, so let it stop the program.
• Using exceptions as normal control flow. Throwing is slow compared with an if check. Check for a zero or a null first when you can.
• Losing the cause. When wrapping one exception in another, pass the original as the cause so the first stack trace is not lost.
• Vague messages. "Error occurred" helps nobody. Include the values involved, like "need 2000, have 1500".

Interview Questions

Summary

• An exception is an object that describes an unexpected event and interrupts normal flow.
• All exception classes descend from Throwable, which splits into Error and Exception.
• RuntimeException and Error are unchecked; other Exception types are checked.
• The compiler forces you to catch or declare checked exceptions.
• An uncaught exception unwinds the stack, skipping the rest of each method on the way.
• Use getMessage() and the class name to report problems clearly.

Related Topics

• try-catch: how to catch exceptions and control what runs next.
• Checked vs Unchecked Exceptions: deeper rules for choosing between the two.
• Custom Exceptions: build your own exception classes like CardBlockedException.
• throws: declaring the exceptions a method passes to its caller.