try, catch, finally

Written Explanation

The basic shape

try {
    // code that might throw
} catch (SomeException e) {
    // plan for SomeException; e is the exception object
} finally {
    // always runs
}

The flow is:

1. Java runs the try block line by line.
2. If nothing is thrown, all catch blocks are skipped.
3. If an exception is thrown, the rest of the try block is skipped, and Java looks for the first catch whose type matches the exception (the same type, or a parent of it). That block runs, and the exception object is available through the parameter, here e.
4. After the catch block, execution continues with the code after the whole statement. The program is not stopped.
5. If no catch matches, the exception keeps propagating up the call stack as in lesson 1.

The variable e has methods you will use: e.getMessage() returns the text, and the exception can be printed or passed on. The next lessons add more.

Catch the narrowest useful type

The type in catch should be the most specific one you can really deal with. catch (NumberFormatException e) says "I know what to do when text is not a number". catch (Exception e) says "anything at all", which includes bugs you did not expect, such as a NullPointerException from a different line, and it makes them all look like bad input. A catch block is a plan; you cannot write a good plan for "anything".

Do not catch more than you handle, and never leave the block empty. An empty catch swallows the problem silently, and lesson 8 of this module is entirely about finding one. At the least, a catch should tell the user or the log what went wrong.

Several catch blocks

If a try can fail in different ways, add one catch per kind. Java checks them top to bottom and runs the first match, so put the specific types first and the general ones last. If a general type comes first, the specific one below can never be reached, and the compiler refuses:

try {
    Integer.parseInt("x");
} catch (RuntimeException e) {
    System.out.println("runtime");
} catch (NumberFormatException e) {
    System.out.println("number");
}

Order.java:7: error: exception NumberFormatException has already been caught

NumberFormatException is a subclass of RuntimeException, so the first block already catches it. Swap the blocks and it compiles.

Multi-catch

Sometimes two different exceptions need exactly the same response. Instead of repeating the block, list the types with |:

catch (NumberFormatException | ArithmeticException e) {
    System.out.println("Cannot compute: " + e.getMessage());
}

The Oracle tutorial describes this form, and notes the catch parameter is implicitly final, so you cannot assign to e in the block. The types must be unrelated: if one alternative is a subclass of another, the compiler rejects it:

Multi.java:5: error: Alternatives in a multi-catch statement cannot be related by subclassing

Use multi-catch only when the response really is the same. If the user-friendly message differs, use separate blocks.

finally

A finally block is for code that must run whether or not the try succeeded. The Oracle tutorial says it runs whenever the try block exits, including normal completion, an exception, and an early return, break, or continue. It is the place for cleanup, such as closing something or recording that a step ended.

A short demonstration with return:

static int test() {
    try {
        System.out.println("in try");
        return 1;
    } finally {
        System.out.println("in finally");
    }
}

Real output of System.out.println("result " + test());:

in try
in finally
result 1

The finally ran after return 1 was decided and before the method actually returned.

The same tutorial points out that finally may not run if the JVM exits while the try or catch code is running. Calling System.exit(...) is the usual way that happens, though the tutorial page does not name it, so treat that example as general Java knowledge. Do not rely on finally to run after a forced shutdown.

For closing files and connections, lesson 6 introduces a better tool than finally. For now, finally is the general mechanism, and you should be able to read code that uses it.

Putting it together

A try needs at least one catch or a finally. You can have any number of catch blocks and at most one finally, always last.