Exception Handling

try, catch & finally

15 min Lesson 2 of 14

try, catch & finally

In the previous lesson you learned what exceptions are and why they exist. Now it is time to learn the three keywords that let you handle them: try, catch, and finally. Together they give you a structured way to wrap risky code, recover from problems, and guarantee cleanup — no matter what happens.

Why wrap code at all?

Without exception handling, any unexpected event — a file that does not exist, a network timeout, a bad user input — crashes your whole program. With a try block you draw a protective boundary around the risky code. If something goes wrong inside that boundary, Java looks for a matching catch block instead of halting.

The try block

A try block contains the statements that might throw an exception. It cannot stand alone — it must be followed by at least one catch block, a finally block, or both.

// basic structure
try {
    // code that might throw
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // handle the problem
    System.out.println("Cannot divide by zero: " + e.getMessage());
}

Here 10 / 0 throws an ArithmeticException. Because the statement is inside a try block, Java transfers control to the matching catch block instead of crashing the application.

The catch block

A catch block declares the type of exception it handles and gives it a local name (by convention e or ex). You can only catch exceptions that are either the exact type thrown or a parent type in the hierarchy (more on that in Lesson 3).

String input = "hello";
try {
    int number = Integer.parseInt(input);   // throws NumberFormatException
    System.out.println("Parsed: " + number);
} catch (NumberFormatException e) {
    System.out.println("Bad input — not a number: " + e.getMessage());
}
// execution continues normally here
System.out.println("Program is still running.");

Notice that the line System.out.println("Parsed: " + number) never runs when parsing fails. Java jumps directly from the point of failure to the catch block, then continues after the entire try-catch construct.

The variable e is an object. It carries information about what went wrong. The most useful methods are e.getMessage() (a short description) and e.toString() (type + message). For debugging during development, e.printStackTrace() prints the full call chain.

Multiple catch blocks

A single try block can be followed by several catch blocks, each handling a different exception type. Java checks them top-to-bottom and runs the first one that matches.

import java.io.*;

public class ReadDemo {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("data.txt");   // may throw FileNotFoundException
            int ch = reader.read();                            // may throw IOException
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

Put more specific exceptions first. FileNotFoundException is a subclass of IOException. If you put the IOException catch block first it would swallow FileNotFoundException too, and the compiler would flag the second block as unreachable. Always order catch blocks from most specific to most general.

The finally block

The finally block runs no matter what — whether the try block succeeded, whether an exception was caught, or even if an exception was thrown and not caught. It is the right place for cleanup code: closing a connection, releasing a lock, flushing a buffer.

import java.io.*;

public class FinallyDemo {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            reader = new FileReader("config.txt");
            // ... read data ...
            System.out.println("File read successfully.");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            // this block ALWAYS runs
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException closeEx) {
                    System.out.println("Could not close file: " + closeEx.getMessage());
                }
            }
            System.out.println("Cleanup done.");
        }
    }
}

Even if new FileReader("config.txt") throws and the catch block runs, the finally block still executes afterward. This guarantee is what makes finally reliable for resource management.

Closing resources in finally is the classic Java pattern. Java 7 introduced try-with-resources as a cleaner alternative for AutoCloseable objects (covered in Lesson 8). For now, understanding the manual finally approach teaches you exactly what try-with-resources does automatically.

Control flow at a glance

If no exception is thrown: try body runs fully, catch is skipped, finally runs.
If a caught exception is thrown: try stops at the throw point, the matching catch runs, finally runs.
If an uncaught exception is thrown: try stops, all catch blocks are skipped, finally still runs, then the exception propagates up the call stack.

Avoid returning from inside finally. If a finally block contains a return statement, it silently discards any exception that was in flight. This is one of the most confusing bugs in Java. Keep finally blocks focused on cleanup, not on returning values.

A complete worked example

Here is a small method that reads an integer from a string, combines all three blocks, and shows the control flow clearly:

public class TryCatchDemo {

    public static int parsePositive(String text) {
        try {
            int value = Integer.parseInt(text);      // may throw NumberFormatException
            if (value <= 0) {
                throw new IllegalArgumentException("Value must be positive, got: " + value);
            }
            return value;                            // only reached on success
        } catch (NumberFormatException e) {
            System.out.println("Not a valid integer: " + e.getMessage());
            return -1;
        } catch (IllegalArgumentException e) {
            System.out.println("Invalid value: " + e.getMessage());
            return -1;
        } finally {
            System.out.println("parsePositive() finished.");  // always prints
        }
    }

    public static void main(String[] args) {
        System.out.println(parsePositive("42"));    // 42
        System.out.println(parsePositive("-5"));    // -1
        System.out.println(parsePositive("abc"));   // -1
    }
}

Summary

Use try to mark code that might fail, catch to handle specific problems gracefully, and finally to guarantee cleanup regardless of outcome. Order multiple catch blocks from specific to general. In the next lesson you will explore the full exception hierarchy so you understand exactly which types to catch and when.