Handling Runtime Exceptions in Java – Explained Simply

You’re writing a Java program, everything looks great, and then—boom! The program crashes because of an unexpected error. What happened? That’s where runtime exceptions come in.

What Are Runtime Exceptions?

A RuntimeException in Java is an error that happens while the program is running. Unlike checked exceptions, Java doesn’t force you to handle them, but if you don’t, your program might unexpectedly crash.

Some common runtime exceptions:

• ArithmeticException – Dividing by zero (10 / 0).
• NullPointerException – Trying to call a method on null.
• ArrayIndexOutOfBoundsException – Accessing an array element that doesn’t exist.
• ClassCastException – Trying to convert one type into another incorrectly.

These exceptions are usually caused by logic errors in your code.

How to Handle Runtime Exceptions

Instead of letting the program crash, we can catch and handle exceptions using try-catch.

Basic Example of try-catch

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // Error: division by zero
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can't divide by zero.");
        }
    }
}

What happens here?

• The program tries to execute the code inside try.
• When 10 / 0 causes an error, the catch block catches it and displays a friendly message instead of crashing.

Handling Multiple Exceptions

What if there are different kinds of errors? You can catch them separately.

public class Main {
    public static void main(String[] args) {
        try {
            String text = null;
            System.out.println(text.length()); // Error: NullPointerException
        } catch (ArithmeticException e) {
            System.out.println("Math error!");
        } catch (NullPointerException e) {
            System.out.println("Something went wrong: text is null.");
        }
    }
}

Here’s how it works:

• If an ArithmeticException happens, the first catch block runs.
• If it’s a NullPointerException, the second catch block runs.

You can also catch multiple exceptions in one line:

catch (ArithmeticException | NullPointerException e) {
    System.out.println("An error occurred: " + e.getMessage());
}

The finally Block – Code That Runs No Matter What

Sometimes, you need to always execute certain code—whether there was an exception or not. That’s what finally is for.

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // Error: index out of bounds
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: No such index in the array!");
        } finally {
            System.out.println("Program execution complete.");
        }
    }
}

Why use finally?

• It always runs, whether an exception happened or not.
• Great for things like closing files, network connections, or cleaning up resources.

Throwing Exceptions with throws

Sometimes, you don’t want to handle an exception right away but instead pass it up to another part of the program. That’s where throws comes in.

public class Main {
    public static void main(String[] args) throws RuntimeException {
        throw new RuntimeException("Something went wrong...");
    }
}

What does this do?

• The method declares that it can throw an exception.
• If an exception occurs, the program crashes with the provided error message.

Best Practices for Handling Exceptions

When should you use try-catch?

• When you expect an error and can handle it gracefully (e.g., user input validation).
• When working with external systems (files, databases, network connections).
• When the error is predictable, and the program can continue running.

When should you NOT use try-catch?

• If the error is caused by a bug in your logic (like dividing by zero)—you should fix the bug instead.
• If catching the error doesn’t actually solve the problem (e.g., catching an exception but not handling it properly).

Final Thoughts

• Runtime exceptions happen at runtime and don’t need to be handled, but you can catch them.
• Use try-catch to handle exceptions and prevent crashes.
• Use finally for code that must always run (like cleanup tasks).
• Use throws if you want to pass the exception to another part of your program.

By handling exceptions properly, you make your code more reliable and less likely to break unexpectedly.