Mastering Java Exception Handling: Try, Catch, Finally, and Resources

Mastering Java Exception Handling

Explore how Java’s try‑catch‑finally mechanisms and try‑with‑resources help you write robust, error‑free code.

The try…catch construct is central to graceful error handling in Java. It allows a program to anticipate runtime problems and respond without crashing.

Below is the canonical syntax:

try {
    // code that may throw an exception
}
catch (ExceptionType e) {
    // handle the exception
}

The try block contains code that might throw an exception. If an exception occurs, control jumps to the matching catch block, which can then react appropriately.

Example: Handling an ArithmeticException

class Main {
    public static void main(String[] args) {
        try {
            int result = 5 / 0;
            System.out.println("This line is never reached.");
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

Output

Caught: / by zero

Here, dividing by zero triggers an ArithmeticException. The catch block captures it, preventing a program crash.

Tip: You can omit the catch block if you’re only interested in ensuring a finally block runs, but a catch cannot exist without a preceding try.

---

Using a Finally Block

A finally clause guarantees execution regardless of whether an exception was thrown:

class Main {
    public static void main(String[] args) {
        try {
            int result = 5 / 0;
        } finally {
            System.out.println("Cleanup actions run here.");
        }
    }
}

Output

Cleanup actions run here.
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at Main.main(Main.java:4)

The finally block executes after the try block, even when an exception interrupts normal flow.

---

Combining Try, Catch, and Finally

Most robust code uses all three clauses to handle errors, report them, and clean up resources. Consider this file‑handling example:

import java.io.*;

class ListOfNumbers {
    private int[] list = {5, 6, 8, 9, 2};

    public void writeList() {
        PrintWriter out = null;
        try {
            System.out.println("Attempting to write to file.");
            out = new PrintWriter(new FileWriter("OutputFile.txt"));
            for (int i = 0; i < 7; i++) {
                out.println("Value at: " + i + " = " + list[i]);
            }
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        } finally {
            if (out != null) {
                System.out.println("Closing PrintWriter");
                out.close();
            } else {
                System.out.println("PrintWriter not opened.");
            }
        }
    }
}

class Main {
    public static void main(String[] args) {
        new ListOfNumbers().writeList();
    }
}

Output

Attempting to write to file.
Exception: Index 5 out of bounds for length 5
Closing PrintWriter

Notice the array’s bounds violation triggers an exception, which is caught and reported. The finally block ensures the PrintWriter is closed, preventing resource leaks.

Best practice: Always place cleanup logic—closing files, sockets, or database connections—in a finally block.

Note: finally may not run if the JVM exits (e.g., System.exit()), an exception occurs within finally, or the thread is abruptly terminated.

---

Handling Multiple Exception Types

A single try can be followed by several catch clauses, each tailored to a specific exception:

class ListOfNumbers {
    private int[] arr = new int[10];

    public void writeList() {
        try {
            arr[10] = 11;
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException: " + e.getMessage());
        } catch (IndexOutOfBoundsException e) {
            System.out.println("IndexOutOfBoundsException: " + e.getMessage());
        }
    }
}

class Main {
    public static void main(String[] args) {
        new ListOfNumbers().writeList();
    }
}

Output

IndexOutOfBoundsException: Index 10 out of bounds for length 10

The runtime first attempts the first catch; if it doesn’t match, it proceeds to the next until a match is found.

---

Catching Multiple Exceptions in One Clause (Java 7+)

Java 7 introduced the ability to combine exception types in a single catch, reducing duplication:

try {
    // risky code
} catch (IOException | SQLException ex) {
    // unified handling
}

Use this feature when different exceptions can be handled identically.

---

Try‑With‑Resources for Automatic Cleanup

The try‑with‑resources statement automatically closes any resource that implements AutoCloseable:

try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt"))) {
    // use the resource
} catch (IOException e) {
    // handle I/O errors
}

Because the resource is declared within the parentheses, it’s closed automatically when the block exits, even if an exception occurs.

For deeper insights, explore the official Java documentation on try‑with‑resources.