Java Unchecked Exceptions Explained: Runtime Errors, Examples & Best Practices

Not every exception in Java must be acknowledged by the compiler. Unchecked exceptions are exceptions that Java does not require you to catch or declare with throws.

They usually represent programming mistakes, invalid assumptions, or invalid operations detected while the program is running. Understanding them is essential because many common Java errors, such as accessing a null reference or using an invalid array index, belong to this category.

What Makes an Exception Unchecked?

An unchecked exception is an exception that extends RuntimeException, either directly or through one of its subclasses.

Throwable
└── Exception
    └── RuntimeException
        ├── NullPointerException
        ├── ArithmeticException
        ├── ArrayIndexOutOfBoundsException
        └── IllegalArgumentException

Because these exceptions are unchecked, the compiler does not force the programmer to handle them.

Remember: Checked exceptions require compile-time handling or declaration. Unchecked exceptions do not.

Why Unchecked Exceptions Exist

Consider this code:

String name = null;

System.out.println(name.length());

The program attempts to call a method through a null reference. Java detects the invalid operation at runtime and throws a NullPointerException.

Java does not require every method that might encounter such a programming mistake to declare NullPointerException. Doing so would make ordinary Java code unnecessarily noisy.

Common Unchecked Exceptions

Exception	Typical Cause
NullPointerException	Attempting to use a null reference where an object is required.
ArithmeticException	An invalid arithmetic operation occurs, such as integer division by zero.
ArrayIndexOutOfBoundsException	An array is accessed using an invalid index.
StringIndexOutOfBoundsException	A string is accessed using an invalid character position.
IllegalArgumentException	A method receives an inappropriate argument.
IllegalStateException	An operation is attempted when an object is in an inappropriate state.
NumberFormatException	A string cannot be converted to the requested numeric format.

NullPointerException

NullPointerException is one of the most frequently encountered unchecked exceptions in Java.

String city = null;

System.out.println(city.toUpperCase());

The variable contains null, so there is no actual String object on which toUpperCase() can operate.

The best solution is usually to correct the program's logic or validate the reference rather than simply catching the exception everywhere.

ArithmeticException

int a = 10;
int b = 0;

int result = a / b;

Integer division by zero causes an ArithmeticException.

The compiler does not require a catch block here because the exception is unchecked.

ArrayIndexOutOfBoundsException

int[] numbers = {10, 20, 30};

System.out.println(numbers[5]);

The valid indexes are 0, 1, and 2. Accessing index 5 is invalid, so Java throws an unchecked exception at runtime.

IllegalArgumentException

This exception is particularly useful when a method receives an argument that violates its contract.

public static void setAge(int age) {

    if (age < 0) {
        throw new IllegalArgumentException(
            "Age cannot be negative."
        );
    }

    System.out.println("Age: " + age);
}

Because IllegalArgumentException extends RuntimeException, the method does not need to declare it using throws.

IllegalStateException

IllegalStateException is useful when the object or application is not currently in a state that allows an operation.

class Printer {

    private boolean ready;

    public void print() {

        if (!ready) {
            throw new IllegalStateException(
                "Printer is not ready."
            );
        }

        System.out.println("Printing...");
    }
}

The problem here is not necessarily the argument. The problem is the current state of the object.

Unchecked Exceptions Do Not Need throws

Consider the following method:

public static void validateAge(int age) {

    if (age < 18) {
        throw new IllegalArgumentException(
            "Age must be at least 18."
        );
    }
}

There is no throws IllegalArgumentException in the method declaration. That is completely valid because the exception is unchecked.

You can still declare it explicitly:

public static void validateAge(int age)
        throws IllegalArgumentException {

    if (age < 18) {
        throw new IllegalArgumentException(
            "Age must be at least 18."
        );
    }
}

However, the declaration is optional.

Unchecked Exceptions and Compiler Freedom

The compiler allows this code:

public static void divide(int a, int b) {
    System.out.println(a / b);
}

There is no requirement to declare or catch ArithmeticException. If b is zero during execution, the exception occurs at runtime.

This gives developers more flexibility, but it also means the responsibility for preventing invalid situations often remains with the programmer.

Checked vs Unchecked Exceptions

Feature	Checked	Unchecked
Compiler enforcement	Must be handled or declared.	No handling or declaration required.
Hierarchy	Exception, excluding RuntimeException branch.	RuntimeException and its subclasses.
Detection	Compiler enforces acknowledgement.	Usually becomes apparent during execution.
Examples	IOException, SQLException.	NullPointerException, IllegalArgumentException.
Typical design focus	External or expected failure conditions.	Invalid state, invalid input, or programming mistakes.

Are Unchecked Exceptions Always Programming Errors?

Not necessarily. Many unchecked exceptions indicate a programming mistake, but some can represent invalid runtime input or application-level conditions.

For example, IllegalArgumentException can be intentionally thrown when a caller supplies an invalid value. The exception is still unchecked even though the validation is deliberate and useful.

Handling Unchecked Exceptions

Unchecked exceptions can absolutely be caught with try-catch.

try {
    int result = 10 / 0;
    System.out.println(result);
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero.");
}

The difference is not whether an unchecked exception can be caught. It can. The difference is that Java does not force you to catch or declare it.

Important: Catching an unchecked exception is not automatically good error handling. If the exception indicates a programming defect, hiding it with a generic catch block may make the application harder to debug.

When Catching Unchecked Exceptions Makes Sense

There are situations where catching an unchecked exception is reasonable. For example, a boundary layer may need to convert invalid input into a user-friendly response.

try {
    int age = Integer.parseInt(input);
    validateAge(age);
} catch (NumberFormatException |
         IllegalArgumentException e) {

    System.out.println(
        "Please enter a valid age."
    );
}

The important point is that the catch block has a meaningful responsibility. It translates a failure into a response the application can actually use.

Preventing Unchecked Exceptions

A strong Java developer does not rely on catch blocks to deal with every unchecked exception. Prevention is often better.

String name = getName();

if (name != null) {
    System.out.println(name.length());
}

The program checks the reference before using it, reducing the chance of a NullPointerException.

Likewise, array indexes should be validated or controlled through safe iteration rather than deliberately allowing an invalid access.

Designing Methods to Avoid Invalid States

Many unchecked exceptions can be reduced through good API design. Instead of allowing an object to enter an invalid state and discovering the problem later, validate important conditions as early as possible.

public class Account {

    private double balance;

    public void withdraw(double amount) {

        if (amount <= 0) {
            throw new IllegalArgumentException(
                "Amount must be positive."
            );
        }

        if (amount > balance) {
            throw new IllegalStateException(
                "Insufficient balance."
            );
        }

        balance -= amount;
    }
}

The method communicates two different problems using two different exception types: an invalid argument and an invalid current state.

Common Beginner Mistakes

• Assuming unchecked exceptions cannot be caught.
• Catching RuntimeException everywhere and ignoring the actual cause.
• Using exceptions instead of validating ordinary input when simple conditions are sufficient.
• Ignoring NullPointerException instead of identifying why a required reference became null.
• Using a generic exception type when a more precise unchecked exception communicates the problem better.
• Assuming that because the compiler does not complain, the code cannot fail at runtime.

Best Practices

• Prevent invalid states whenever practical.
• Use precise unchecked exception types that describe the failure accurately.
• Catch unchecked exceptions only when the current layer can make a meaningful decision.
• Do not silently ignore runtime exceptions.
• Use validation and clear method contracts to reduce avoidable runtime failures.
• Preserve useful debugging information when an unchecked exception must be translated or rethrown.

Interview Insights

A common interview question is: "What is an unchecked exception?" A concise answer is: an unchecked exception is a RuntimeException or one of its subclasses, and the compiler does not require the programmer to catch or declare it.

Another common question is: "Can we use throws with an unchecked exception?" Yes. It is legal, but it is optional.

You may also be asked whether unchecked exceptions should always be avoided. No. They are an important part of Java's exception model and are appropriate for many programming errors, invalid arguments, and invalid object states.

Quick Revision

Concept	Key Idea
Unchecked exception	A RuntimeException or subclass not subject to compiler handling requirements.
Compiler	Does not require catch or throws.
Examples	NullPointerException, ArithmeticException, IllegalArgumentException.
Handling	Can be caught when meaningful recovery or translation is possible.
Prevention	Good validation and API design can prevent many runtime failures.
Custom exception	Extending RuntimeException creates an unchecked custom exception.

Unchecked exceptions give Java developers flexibility by avoiding mandatory compiler handling for every runtime failure. They are especially useful for invalid arguments, invalid object states, and programming defects that should often be prevented rather than routinely caught. Once you understand both checked and unchecked exceptions, the next step is learning how to design your own exception types for application-specific failures.