What are Runtime errors in Java | Explained

In java, an unwanted event that terminates the program’s execution is known as an error. It occurs either because of syntactical issues or some other issues that can’t be detected at compile time. The errors that can’t be detected at compile-time and hence occur at the time of program execution are known as runtime errors while the errors with syntactical issues are referred to as compile-time errors.

This article presents a detailed overview of runtime errors in java and in this regard, we need to understand the following concepts:

So, let’s get started!

What are Runtime Errors in Java?

The errors that occur at the time of program execution are referred as runtime errors. These types of errors can’t be detected at the compile time as there is nothing wrong with their syntax. So, we can say that the program that is syntactically correct still throws an error at the time of program execution is called a runtime error.

Types of Runtime Errors in Java

There are multiple types of runtime errors that we can face at the time of program execution. Some frequently encountered runtime errors are listed below:

  • Input-output errors
  • Infinite loop error
  • Division by zero errors
  • Logic Errors
  • Out of range errors
  • Undefined object error

Factors that Cause Runtime Errors

There are numerous factors that cause Runtime errors, among them the most commonly encountered causes are listed below:

  • Dividing any numeric value by zero produces runtime errors.
  • Accessing an array-out-of-bounds.
  • Passing invalid data e.g. passing a numeric value to the non-numeric field.
  • Passing invalid parameters/arguments to a method.
  • Multiple processes trying to access the same resource at the same time.
  • Trying to store an incompatible type value to a collection.
  • Insufficient space/memory error in threads (OutOfMemoryError)

Examples of Runtime Errors

Let’s understand the concept of runtime errors with the help of examples.


In this example, we have an array of size three:

public class RuntimeErrorsExample {
public static void main(String[] args) {
int ary[] = {4, 6, 2};
System.out.println("Result: " + ary[3]);

The array’s length is three and we knew that the array’s indexing starts from zero. So, specifying ary[3] means we are trying to access the fourth element of the array. Syntactically, nothing wrong with it so, we didn’t face any error at compile time. However, the JVM will throw the error at runtime:

From the above snippet, we observe that an error occurs at run time when we try to access the out-of-range index.

For the clarity of concept let’s consider another example:


This time we have a string assigned with a “null” value and we will try to find the length of the string:

public class RuntimeErrorsExample {
public static void main(String[] args) {
String str = null;

Following will be the output for the above code snippet:

When we run the program, we encounter a NullPointerException because the string is null.

So, how to handle such runtime errors? Does java provide a solution to deal with such runtime errors? Of course, Java does.

How to Handle Runtime Errors

In java, Runtime errors can be solved with the help of try-catch statements, and to do so, we have to put the code that can throw a runtime error in the try-catch statements.


Let’s consider the below code snippet to understand how to solve runtime errors using try-catch statements in java:

public class RuntimeErrorsExample {
public static void main(String[] args) {
try {
int number1 = 110, number2 = 0;
System.out.println("Outcome: " + number1 / number2);
} catch (ArithmeticException excep) {
System.out.println("Numeric values can't be divided by 0");

Now we surrounded the code within the try-catch statements that can throw the error:

Now this time instead of throwing the error, JVM shows the message that we specified within the catch block.


In Java, the programs that are syntactically correct but still throw some errors at the time of program execution are known as runtime errors. These errors occur because of different reasons such as division by zero, accessing an array out of bounds, passing invalid data e.g. passing a numeric value to the non-numeric field, etc. These types of errors can be handled by surrounding the try-catch block around the code that can throw the runtime errors. This write-up explains different aspects of runtime errors for example what are runtime errors, their types, causes, and how to fix these errors in java.

About the author

Anees Asghar

I am a self-motivated IT professional having more than one year of industry experience in technical writing. I am passionate about writing on the topics related to web development.