Exception handling: try, catch, finally, throw, throws

It is easy to write what a program does when everything is fine. Exception handling organizes what happens when things go wrong: the user types a letter instead of a number, the file does not exist, an array bound is exceeded. In the exam this topic almost always comes as a “What is printed?” tracing question: which lines are skipped, which catch runs, where finally steps in. Alongside it come compile errors about checked exceptions and the “write your own exception class” question.

Golden rules:

1. The moment an exception is thrown, the rest of the try block is skipped. Control goes to the matching catch.
2. Catches are tried from top to bottom, and the first one that fits runs. What fits is the exception’s own type or its superclass.
3. finally always runs: with or without an exception, even with a return.
4. An uncaught exception ends the method immediately and passes to the caller (stack unwinding).
5. A checked exception is either caught or declared with throws. There is no such requirement for unchecked ones (RuntimeException).

try, catch, finally

try {
    int[] arr = {1, 2, 3};
    System.out.println(arr[1]);
    System.out.println(arr[3]);        // the exception happens here
    System.out.println("not printed"); // skipped
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught: " + e.getMessage());
} finally {
    System.out.println("finally");
}
System.out.println("after");

2
Caught: Index 3 out of bounds for length 3
finally
after

Rules:

• A try cannot stand alone: it needs at least one catch or one finally. Otherwise 'try' without 'catch', 'finally' or resource declarations.
• A try can have more than one catch; only one of them runs.
• finally is optional; if present, it runs once at the very end. It is used for closing resources (files, connections).

Multiple catches and their order

static void trace(int k) {
    try {
        System.out.print("A");
        if (k == 1) throw new IllegalStateException();
        if (k == 2) throw new IllegalArgumentException();
        System.out.print("B");
    } catch (IllegalStateException e) {
        System.out.print("C");
    } catch (RuntimeException e) {       // superclass: catches every RuntimeException
        System.out.print("D");
    } finally {
        System.out.print("E");
    }
    System.out.println("F");
}
trace(0);
trace(1);
trace(2);

ABEF
ACEF
ADEF

If you write a general catch (Exception, RuntimeException) before specific ones, the catch below it never gets its turn and the compiler counts this as an error: exception NumberFormatException has already been caught.

Multi-catch: to combine catches that do the same job, write catch (NumberFormatException | ArithmeticException e). The list cannot contain types that are subclasses of each other.

static void parse(String s) {
    try {
        int n = Integer.parseInt(s);
        System.out.println(100 / n);
    } catch (NumberFormatException | ArithmeticException e) {
        System.out.println("bad input: " + e.getClass().getSimpleName());
    }
}
parse("4"); parse("x"); parse("0");

25
bad input: NumberFormatException
bad input: ArithmeticException

finally and return

static int f() {
    try { return 1; }
    finally { System.out.println("finally in f"); }
}
static int h() {
    int x = 10;
    try { return x; }          // the return value was stored as 10
    finally { x = 20; }        // does not affect the stored value
}
System.out.println(f());
System.out.println(h());

finally in f
1
10

PITFALL · return inside finally. If you write return 2; in finally, even an exception thrown from the try is swallowed and the method returns 2 (in the test run, a try with throw new RuntimeException and a finally with return 2 silently returned 2). The compiler does not reject it (it only warns when -Xlint is on); never write it like this, but if you see it in the exam, the answer is the value in finally.

The exception hierarchy: checked and unchecked

Throwable
 ├─ Error                       (JVM problems: OutOfMemoryError, StackOverflowError; not caught)
 └─ Exception                   (CHECKED: the compiler checks)
     ├─ IOException
     │    └─ FileNotFoundException
     ├─ (your own extends Exception classes)
     └─ RuntimeException        (UNCHECKED: the compiler stays out)
          ├─ ArithmeticException
          ├─ NullPointerException
          ├─ ClassCastException
          ├─ IndexOutOfBoundsException
          │    ├─ ArrayIndexOutOfBoundsException
          │    └─ StringIndexOutOfBoundsException
          └─ IllegalArgumentException
               └─ NumberFormatException

Common unchecked exceptions and the one-liners that produce them:

String s = null; s.length();          // NullPointerException
Object o = "hi"; Integer i = (Integer) o;   // ClassCastException
System.out.println(10 % 0);           // ArithmeticException: / by zero
System.out.println(10.0 / 0);         // NO exception: Infinity

NullPointerException
ClassCastException
ArithmeticException: / by zero
Infinity

(The output of the first three lines was obtained by running each in a try/catch and printing the name of the caught exception.)

throw and throws

• throw throws an exception. An object follows it: throw new IllegalArgumentException("amount must be positive");
• throws in a method’s signature declares which checked exceptions this method may let out: void withdraw(double a) throws InsufficientFundsException.

If you call a method that throws or may throw a checked exception, you have two options: catch it with try/catch, or add throws to your own signature and pass the responsibility up. If you do neither: unreported exception X; must be caught or declared to be thrown.

There is also a rule in the opposite direction: if nothing in the try block can throw a checked exception, you cannot catch it: exception IOException is never thrown in body of corresponding try statement.

Stack unwinding

If an exception happens in a method and is not caught there, the method ends at that moment. The exception behaves as if it were “thrown” to the place that called the method. The call stack is unwound this way until a catch that catches it is found. Every finally on the way runs.

static void level3() {
    System.out.println("level3 start");
    int[] a = new int[2];
    a[5] = 1;                                   // exception
    System.out.println("level3 end");
}
static void level2() {
    System.out.println("level2 start");
    try { level3(); }
    finally { System.out.println("level2 finally"); }
    System.out.println("level2 end");
}
static void level1() {
    System.out.println("level1 start");
    try { level2(); }
    catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("level1 caught: " + e.getMessage());
    }
    System.out.println("level1 end");
}
level1();

level1 start
level2 start
level3 start
level2 finally
level1 caught: Index 5 out of bounds for length 2
level1 end

main → level1 → level2 → level3        (call stack)
level3: a[5] → exception, no catch → level3 ends (no "end")
level2: no catch, finally EXISTS → "level2 finally" → exception continues (no "end")
level1: the catch fits → "level1 caught..." → normal flow → "level1 end"

If the exception goes all the way up to main and is not caught there either, the program ends and the JVM prints the stack trace. When level3() is called directly from main:

level3 start
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 2
	at W09.level3(W09.java:31)
	at W09.main(W09.java:221)

A stack trace is read from the bottom up: main called level3; the exception happened at line 31 of level3.

Your own exception class

To report business-rule violations (insufficient balance, invalid grade) with a meaningful type, you write your own exception class. Derive from Exception if you want it to be checked, from RuntimeException if you want it unchecked. Pass the message with super(message).

class InsufficientFundsException extends Exception {
    private final double shortfall;
    public InsufficientFundsException(String message, double shortfall) {
        super(message);
        this.shortfall = shortfall;
    }
    public double getShortfall() { return shortfall; }
}

class Account {
    private double balance;
    Account(double b) { balance = b; }
    void withdraw(double amount) throws InsufficientFundsException {
        if (amount <= 0) throw new IllegalArgumentException("amount must be positive");
        if (amount > balance)
            throw new InsufficientFundsException("Not enough money", amount - balance);
        balance -= amount;
    }
    double getBalance() { return balance; }
}

Account acc = new Account(100);
try {
    acc.withdraw(30);
    acc.withdraw(100);
    System.out.println("not printed");
} catch (InsufficientFundsException e) {
    System.out.println(e.getMessage() + ", short by " + e.getShortfall());
}
System.out.println(acc.getBalance());
try {
    acc.withdraw(-5);
} catch (InsufficientFundsException e) {
    System.out.println("checked");
} catch (IllegalArgumentException e) {
    System.out.println("unchecked: " + e.getMessage());
}

Not enough money, short by 30.0
70.0
unchecked: amount must be positive

Methods of the exception object

Catching an exception and wrapping it in a more meaningful one is called exception chaining: throw new IOException("load failed", e);. Then e.getCause().getMessage() gives the real reason (data.txt).

Common mistakes

try {
    int[] arr = {1, 2, 3};
    System.out.println(arr[1]);
    System.out.println(arr[3]);
    System.out.println("not printed");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught: " + e.getMessage());
} finally {
    System.out.println("finally");
}
System.out.println("after");

static void trace(int k) {
    try {
        System.out.print("A");
        if (k == 1) throw new IllegalStateException();
        if (k == 2) throw new IllegalArgumentException();
        System.out.print("B");
    } catch (IllegalStateException e) {
        System.out.print("C");
    } catch (RuntimeException e) {
        System.out.print("D");
    } finally {
        System.out.print("E");
    }
    System.out.println("F");
}

static void level3() {
    System.out.println("level3 start");
    int[] a = new int[2];
    a[5] = 1;
    System.out.println("level3 end");
}
static void level2() {
    System.out.println("level2 start");
    try { level3(); }
    finally { System.out.println("level2 finally"); }
    System.out.println("level2 end");
}
static void level1() {
    System.out.println("level1 start");
    try { level2(); }
    catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("level1 caught: " + e.getMessage());
    }
    System.out.println("level1 end");
}

static int f() {
    try { return 1; }
    finally { System.out.println("finally in f"); }
}
static int h() {
    int x = 10;
    try { return x; }
    finally { x = 20; }
}
// in main:
System.out.println(f());
System.out.println(h());

static void open(String name) {
    throw new FileNotFoundException(name);
}

try {
    int x = Integer.parseInt("12");
} catch (Exception e) {
    System.out.println("general");
} catch (NumberFormatException e) {
    System.out.println("number");
}

try {
    System.out.println("hi");
} catch (IOException e) {
    System.out.println("io");
}

Exception ex = new IllegalArgumentException("bad value");
System.out.println(ex.getMessage());
System.out.println(ex);
System.out.println(new RuntimeException().getMessage());

static void parse(String s) {
    try {
        int n = Integer.parseInt(s);
        System.out.println(100 / n);
    } catch (NumberFormatException | ArithmeticException e) {
        System.out.println("bad input: " + e.getClass().getSimpleName());
    }
}
// in main:
parse("4"); parse("x"); parse("0");

class InsufficientFundsException extends Exception {
    private final double shortfall;
    InsufficientFundsException(String msg, double shortfall) {
        super(msg); this.shortfall = shortfall;
    }
    double getShortfall() { return shortfall; }
}
// Account.withdraw throws it when amount > balance, otherwise subtracts
Account acc = new Account(100);
try {
    acc.withdraw(30);
    acc.withdraw(100);
    System.out.println("not printed");
} catch (InsufficientFundsException e) {
    System.out.println(e.getMessage() + ", short by " + e.getShortfall());
}
System.out.println(acc.getBalance());

public class InvalidAgeException extends Exception {
    public InvalidAgeException(String msg) { super(msg); }
}

public static int readAge(String text) throws InvalidAgeException {
    int age;
    try {
        age = Integer.parseInt(text.trim());
    } catch (NumberFormatException e) {
        throw new InvalidAgeException("not a number: " + text);
    }
    if (age < 0 || age > 150)
        throw new InvalidAgeException("out of range: " + age);
    return age;
}