Java RuntimeException

last modified April 2, 2025

RuntimeException is a special category of exceptions in Java that represents problems which may occur during normal program execution. Unlike checked exceptions, RuntimeExceptions are not verified at compile time.

The key characteristic of RuntimeException is that it's unchecked - methods don't need to declare they might throw it, and callers aren't forced to handle it. This makes RuntimeExceptions suitable for indicating programming errors rather than recoverable conditions.

Understanding RuntimeException

RuntimeException sits at the top of the unchecked exception hierarchy. It extends Exception but is specially marked in Java's exception handling mechanism to bypass compile-time checking.

The Java Language Specification states that RuntimeExceptions "are exempted from compile-time checking because they can occur at many points in a program and having to declare them would clutter the program."

Throwable
    ├── Exception
    │     ├── RuntimeException
    │     │     ├── NullPointerException
    │     │     ├── IllegalArgumentException
    │     │     └── ...others...
    │     └── ...checked exceptions...
    └── Error

When to Use RuntimeException

RuntimeException should be used for conditions that:

• Represent programming errors rather than external conditions
• Are generally unrecoverable
• Would clutter code if required to be declared or caught
• Indicate violations of API contracts

Good candidates for RuntimeException include parameter validation failures, illegal state conditions, and other cases where the error results from incorrect program logic rather than environmental factors.

Throwing RuntimeException

You can throw RuntimeException directly or create custom subclasses. The basic pattern is similar to other exceptions:

void processInput(String input) {
    if (input == null) {
        throw new RuntimeException("Input cannot be null");
    }
    // Process the input
}

This example shows basic RuntimeException usage for parameter validation. The exception will propagate up the call stack until caught or until it terminates the thread.

Creating Custom RuntimeExceptions

For more specific error handling, you can create custom RuntimeException subclasses. This follows the same pattern as other custom exceptions:

class ConfigurationException extends RuntimeException {
    public ConfigurationException(String message) {
        super(message);
    }
    
    public ConfigurationException(String message, Throwable cause) {
        super(message, cause);
    }
}

void loadConfig(String path) {
    if (!isValidConfig(path)) {
        throw new ConfigurationException("Invalid configuration: " + path);
    }
    // Load configuration
}

This custom RuntimeException provides more specific error information while maintaining the unchecked nature of RuntimeException.

Handling RuntimeException

While not required, you can catch RuntimeException like any other exception. This is often done at strategic boundaries in the application:

void processRequest(Request request) {
    try {
        validateRequest(request);
        executeRequest(request);
    } catch (RuntimeException e) {
        log.error("Request processing failed", e);
        throw new ServiceException("Request failed", e);
    }
}

This example shows catching RuntimeException at a service boundary, logging it, and potentially converting it to another exception type for the caller.

Best Practices

When working with RuntimeException:

• Use for programming errors, not expected error conditions
• Document when methods might throw RuntimeExceptions
• Consider creating specific subclasses for important cases
• Catch at appropriate boundaries (like service layers)
• Don't use RuntimeException to avoid proper error handling

When Not to Use RuntimeException

Avoid RuntimeException for:

• Conditions callers should reasonably handle
• Expected error cases (use checked exceptions)
• Situations where recovery is possible and expected
• Cases where forcing callers to handle is beneficial

Source

Oracle RuntimeException Documentation

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Java tutorials.