try, catch, and finally

The try-catch-finally construct is the core syntax Java provides for handling exceptions. Code that might throw an exception is placed inside a try block, the recovery logic goes in one or more catch blocks matched by exception type, and a finally block holds cleanup code that must run no matter what happened.

Why it matters

try, catch and finally are the three parts you use in almost every piece of code that touches files, networks or user input. The order of catch blocks, what finally guarantees, and how try-with-resources closes things for you are details that decide whether a failure is handled cleanly or leaks a connection.

Multiple catch Blocks and Multi-catch

A single try block can be followed by several catch blocks, each handling a different exception type; Java checks them in order and executes the first one whose type matches (or is a superclass of) the thrown exception, so more specific exception types must be listed before more general ones. When two or more exception types should be handled identically, Java lets you combine them into one multi-catch block using a pipe: catch (IOException | SQLException e). This avoids duplicating the same handling code, but the exception types in a multi-catch must not be related by inheritance to each other.

The finally Block

Code inside finally runs after the try block completes, regardless of whether an exception was thrown, whether it was caught, or even whether the try or catch block executed a return statement. This makes finally the correct place for cleanup that absolutely must happen — closing a file, releasing a lock, or closing a database connection — because it runs in almost every circumstance, including when the method is about to return a value.

try-with-resources

Manually closing resources in a finally block is verbose and error-prone. Java's try-with-resources statement automatically closes any resource that implements the AutoCloseable interface once the try block finishes, whether normally or via an exception — you declare the resource inside the parentheses of the try statement itself, and no explicit finally or close() call is needed.

• try (FileReader fr = new FileReader("data.txt")) { ... } closes fr automatically.
• Resources are closed in reverse order of declaration if multiple are opened in one try-with-resources.
• The resource variable is implicitly final and closed even if an exception occurs inside the try block.

Example

public class TryCatchDemo {
    static int divide(int a, int b) {
        try {
            return a / b;
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
            return -1;
        } finally {
            System.out.println("finally always runs");
        }
    }

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

Caught: / by zero
finally always runs
Result: -1
finally always runs
Result: 5

Exercise

Add up the numbers in an array of text values. One value is not a number: skip it, print which one was skipped, and keep going.

Expected output: Skipped x then Sum: 40

public class SumValid {
    public static void main(String[] args) {
        String[] values = {"10", "x", "30"};
        int sum = 0;

        for (String value : values) {
            // TODO: parse value and add it to sum;
            // if it is not a number, print "Skipped " + value
        }

        System.out.println("Sum: " + sum);
    }
}

public class SumValid {
    public static void main(String[] args) {
        String[] values = {"10", "x", "30"};
        int sum = 0;

        for (String value : values) {
            try {
                sum += Integer.parseInt(value);
            } catch (NumberFormatException e) {
                System.out.println("Skipped " + value);
            }
        }

        System.out.println("Sum: " + sum);
    }
}

Quick quiz

Interview questions