Exceptions, Errors, and the Stack Trace

Java gives failures their own channel. A method that cannot continue throws, and normal execution stops there.

int divide(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("cannot divide by zero");
    }
    return a / b;
}

An exception is an object, made with new like any other. What makes it special is what happens next.

The stack unwinds. Java abandons divide and looks at whoever called it. If that method does not handle it, that one is abandoned too, and so on down the stack. It keeps going until something catches it or main runs out, and then the program stops and the trace is printed.

Catching it happens where you know what to do:

try {
    int result = divide(10, 0);
    System.out.println(result);
} catch (ArithmeticException e) {
    System.out.println("cannot divide by zero, using 0 instead");
    result = 0;
}

The try block holds the code that might fail. The catch block runs only if it does, and only for the type it names. Notice that divide was not changed at all. Reporting and handling are now in different places, which was the point.

finally runs whatever happens:

Scanner in = null;
try {
    in = new Scanner(new File("data.txt"));
    return in.nextLine();
} catch (FileNotFoundException e) {
    return "no file";
} finally {
    if (in != null) in.close();      // runs on success, on failure, and on return
}

It runs after a normal finish, after a caught exception, and even after a return. That makes it the place for cleanup, and cleanup is why it exists.

Then Java 7 made most of that unnecessary:

try (Scanner in = new Scanner(new File("data.txt"))) {
    return in.nextLine();
} catch (FileNotFoundException e) {
    return "no file";
}

Anything declared in those brackets is closed for you, in every case. This is try-with-resources, it works on anything implementing AutoCloseable, and the streams from Section 8.1 all do.

Error and Exception are siblings, not parent and child.

Throwable                 the only thing throw and catch will accept
├── Error                 the machine is in trouble
│     OutOfMemoryError, StackOverflowError. Do not catch these.
└── Exception             your program is in trouble, and may recover

Error and Exception both extend Throwable, and neither extends the other. So catch (Exception e) cannot catch an OutOfMemoryError by accident, which is exactly what you want. A broad catch in your code should not be able to swallow the JVM telling you it has run out of memory.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. Why can a method not report a failure by returning a value?

   Show the answer

   Because every value it could return is one a caller might legitimately want.

   divide returning -1 to mean failure is broken the moment a real answer is -1. Returning 0 has the same problem. There is no int that means "this did not work", so the caller cannot tell the difference between an answer and a complaint.

   Even where a spare value exists, like null, nothing forces the caller to look. The signature says it returns a value, so ignoring the failure is the easiest thing to write.

   An exception is on a separate channel. It cannot be mistaken for an answer, and ignoring it is not something you can do by accident.

2. Which end of a stack trace do you read first?

   Show the answer

   The top line for what went wrong, then straight to the first line mentioning your own code for where.

   The order is the call stack from Section 5.1, printed innermost first. Line one is the method that threw. The bottom is main. Everything in between is how you arrived.

   The first few frames are often inside the JDK, so the useful line is usually the first one with your package name on it. That is where your code called something that failed.

   Then look for Caused by: lower down. A wrapped exception puts the real cause there, and the original failure can be twenty lines below the one you read first.

3. What separates an `Error` from an `Exception`, and why does `catch (Exception e)` not catch both?

   Show the answer

   An Exception is a problem in your program that your program might be able to do something about. A file is missing, a number will not parse, an index is out of range.

   An Error is a problem with the machine your program is running on. OutOfMemoryError, StackOverflowError. There is usually nothing sensible to do, because the thing you would do to recover also needs the resource that has run out.

   They are siblings. Both extend Throwable, and neither extends the other, so catch (Exception e) cannot catch an Error even by accident. That separation is deliberate: it means a broad catch in your code cannot quietly swallow the JVM telling you it is in trouble.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises90 pointsabout 95 minutes

class ReadIt {
    static List<String> framesFrom(Runnable work)
    static String typeOf(Runnable work)
    static String messageOf(Runnable work)
    static List<String> divideByZeroFrames()
    static List<String> badIndexFrames()
    static List<String> nullFrames()
    static String methodThatThrew()
    static String methodWithTheMistake()
}

import java.util.*;

public class ReadIt {

    static int divide(int a, int b) { return a / b; }
    static int compute(int a) { return divide(100, a); }
    static void level3(int a) { compute(a); }
    static void level2(int a) { level3(a); }
    static void level1(int a) { level2(a); }

    // Run the work, catch whatever comes out, and return OUR method names,
    // innermost first.
    static List<String> framesFrom(Runnable work) { return List.of(); }  // TODO

    static String typeOf(Runnable work)    { return ""; }  // TODO
    static String messageOf(Runnable work) { return ""; }  // TODO

    static List<String> divideByZeroFrames() { return List.of(); }  // TODO
    static List<String> badIndexFrames()     { return List.of(); }  // TODO
    static List<String> nullFrames()         { return List.of(); }  // TODO

    // Which method threw, and which method actually made the mistake?
    static String methodThatThrew()      { return ""; }  // TODO
    static String methodWithTheMistake() { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: call level1(0) and read the WHOLE trace before doing anything
    }
}

class Swallow {
    static int one()
    static int two()
    static String three()
    static int oneFixed()
    static String oneThrows()
    static String oneFixedThrows()
    static String bufferAfterThree()
}

public class Swallow {

    // Leave these three exactly as they are. PREDICT all three first.
    static int one() {
        try { throw new IllegalStateException("boom"); }
        finally { return 42; }
    }

    static int two() {
        try { return 1; }
        finally { return 2; }
    }

    static String three() {
        StringBuilder sb = new StringBuilder();
        try { sb.append("try "); return sb.toString() + "|end"; }
        finally { sb.append("finally "); }
    }

    static boolean cleanedUp = false;

    // The same as one(), with finally doing cleanup ONLY.
    static int oneFixed() { return 0; }  // TODO

    // Did an exception escape? "threw" or "no exception".
    static String oneThrows()      { return ""; }  // TODO
    static String oneFixedThrows() { return ""; }  // TODO

    // Did finally change the buffer? Return what the caller receives.
    static String bufferAfterThree() { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: predict all three, then run them
    }
}

class Resources {
    static List<String> closeOrder()
    static List<String> closedAfterThrow()
    static String bodyExceptionMessage()
    static String suppressedMessage()
}

import java.util.*;

public class Resources {

    static final List<String> log = new ArrayList<>();

    static class Res implements AutoCloseable {
        final String name;
        final boolean failOnClose;
        Res(String name) { this(name, false); }
        Res(String name, boolean failOnClose) {
            this.name = name;
            this.failOnClose = failOnClose;
            // TODO: record "open " + name
        }
        @Override public void close() {
            // TODO: record "close " + name, then throw if failOnClose
        }
    }

    // Open two, do something, and report the order everything happened in.
    static List<String> closeOrder() { return List.of(); }  // TODO

    // Same, but the body throws. Are they still closed?
    static List<String> closedAfterThrow() { return List.of(); }  // TODO

    // Body throws AND close throws. Which one comes out, and where does the other go?
    static String bodyExceptionMessage() { return ""; }  // TODO
    static String suppressedMessage()    { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: predict the close order before running
        // TODO: write the same thing with finally instead, and count the lines
    }
}

class NotYours {
    static int forever(int depth)
    static int overflowDepth()
    static String caughtAsException()
    static String caughtAsThrowable()
    static boolean errorIsAnException()
    static boolean runtimeIsAnException()
    static boolean errorIsThrowable()
}

public class NotYours {

    static int deepestReached = 0;

    static int forever(int depth) { return 0; }  // TODO: recurse, recording the depth

    static int overflowDepth() { return 0; }  // TODO: catch the Error, return how deep it got

    // Put BOTH a catch of Exception and a catch of StackOverflowError around it.
    // Which one runs? Return "caught as Exception" or "only caught as Error".
    static String caughtAsException() { return ""; }  // TODO

    // And with a catch of Throwable instead.
    static String caughtAsThrowable() { return ""; }  // TODO

    // Ask the TYPE SYSTEM, do not return a constant you remembered.
    static boolean errorIsAnException()   { return true; }  // TODO
    static boolean runtimeIsAnException() { return false; } // TODO
    static boolean errorIsThrowable()     { return false; } // TODO

    public static void main(String[] args) {
        // TODO: find how deep this machine goes, then try -Xss256k and compare
    }
}