Difference between java.lang.RuntimeException and java.lang.Exception

java

exception-handling

best-practices

java-exception

byAlex Kataev·Sep 23, 2024

RuntimeExceptions are unchecked exceptions, implying they don't need to be formally addressed or declared thrown. They point mainly at coding blunders, like NullPointerException or ArrayIndexOutOfBoundsException.

Contrarily, standard Exceptions (not being subclasses of RuntimeException) are checked, demanding explicit code control via try-catch blocks or throws clauses. They represent recoverable aberrations and anticipated disruptions in normal execution flow, like IOException.

Unchecked (RuntimeException):

void uncheckedDemo() {
  // No need for try-catch; just crashing the party like a rockstar!
  throw new RuntimeException("Fail fast");
}

Checked (Exception):

void checkedDemo() throws Exception {
  // Compiler is your party guard here, handle it or... exit through the window!
  throw new Exception("Handle me wisely");
}

Choosing RuntimeException over Exception

Enforcing catch blocks using checked exceptions

When designing a library or an API, if you extend Exception, manifesting as checked exceptions, you're alerting the API user that they must handle the potential disruption distinctly. An example could be disk I/O operations which throw IOException, requiring the programmer to deal with possible outcomes like file not found or access permissions error.

Preventing common coding slip-ups

Unchecked exceptions usually flag developer errors like accessing a null object or exceeding array length. In these situations, extending RuntimeException is advantageous as the consequences of such mishaps should never occur during normal operation and should be corrected at the earliest.

Designing custom exceptions

While creating a custom exception class, the first thing to consider is the exception's outcome on the caller. Will they be able to alleviate the situation? If not, should these conditions ever arise under regular functioning? Your answer will guide whether to extend Exception or RuntimeException.

Cleaner code without bulky exception handling

Excessive use of checked exceptions introduces code clutter, with redundant try-catch blocks or throws declarations confusing the program flow. Unchecked exceptions lead to less verbose code, as they eliminate the need for routine exception handling that might remain unused.

Digging Deep: Exception hierarchy and coding practices

Understanding the Java exception hierarchy

The exception classification in Java commences with Throwable, splits into Error and Exception, and then further into RuntimeException. Having a grip on this hierarchy aids in choosing the right kind of exception when designing custom exception classes.

Declaring exceptions in code

When coding methods, it is advisable to list the exceptions they might throw using throws. This approach improves the communication between the method and its callers, allowing them to implement defensive code.

Achieving appropriate exception handling balance

If a method throws numerous checked exceptions, it can suggest that the function is overloaded or that the exceptions should be wrapped into a single custom exception to simplify the API. Avoid too many unchecked exceptions to ensure essential issues don't go unattended.

Tackling unchecked exceptions

Checking programming errors early is beneficial in applications where unchecked exceptions are more suitable. To achieve this, consider using assertions or precondition checks, which allow you to spot the error right when it happens, rather than allowing the program to proceed in an unstable state.

explain-codes / Java / Difference between java.lang.RuntimeException and java.lang.Exception

Linked

What is the difference between Errors and Exceptions?



How to define custom exception class in Java, the easiest way?



How to create custom exceptions in Java?



Is it a good practice to use try-except-else in Python?



How can I write a `try`/`except` block that catches all exceptions?

