What are Null Pointer Exceptions (java.lang.NullPointerException) and what causes them?

What methods/tools can be used to determine the cause so that you stop the exception from causing the program to terminate prematurely?

java nullpointerexception 

Nov 17

4 Answers

When you declare a reference variable (i.e., an object), you are really creating a pointer to an object. Consider the following code where you declare a variable of primitive type int:

int x;
x = 10;

In this example, the variable x is an int and Java will initialize it to 0 for you. When you assign the value of 10 on the second line, your value of 10 is written into the memory location referred to by x.

But, when you try to declare a reference type, something different happens. Take the following code:

Integer num;
num = new Integer(10);

The first line declares a variable named num, but it does not actually contain a primitive value yet. Instead, it contains a pointer (because the type is Integer which is a reference type). Since you have not yet said what to point to, Java sets it to null, which means "I am pointing to nothing".

In the second line, the new keyword is used to instantiate (or create) an object of type Integer, and the pointer variable num is assigned to that Integer object.

The NullPointerException (NPE) occurs when you declare a variable but did not create an object and assign it to the variable before trying to use the contents of the variable (called dereferencing). So you are pointing to something that does not actually exist.

Dereferencing usually happens when using . to access a method or field, or using [ to index an array.

If you attempt to dereference num before creating the object you get a NullPointerException. In the most trivial cases, the compiler will catch the problem and let you know that "num may not have been initialized," but sometimes you may write code that does not directly create the object.

For instance, you may have a method as follows:

public void doSomething(SomeObject obj) {
   // Do something to obj, assumes obj is not null
   obj.myMethod();
}

In which case, you are not creating the object obj, but rather assuming that it was created before the doSomething() the method was called. Note, it is possible to call the method like this:

doSomething(null);

In which case, obj is null, and the statement obj.myMethod() will throw a NullPointerException.

If the method is intended to do something to the passed-in object as the above method does, it is appropriate to throw the NullPointerException because it's a programmer error and the programmer will need that information for debugging purposes.

In addition to NullPointerExceptions thrown as a result of the method's logic, you can also check the method arguments for null values and throw NPEs explicitly by adding something like the following near the beginning of a method:

// Throws an NPE with a custom error message if obj is null
Objects.requireNonNull(obj, "obj must not be null");

Note that it's helpful to say in your error message clearly which object cannot be null. The advantage of validating this is that 1) you can return your own clearer error messages and 2) for the rest of the method you know that unless obj is reassigned, it is not null and can be dereferenced safely.

Alternatively, there may be cases where the purpose of the method is not solely to operate on the passed-in object, and therefore a null parameter may be acceptable. In this case, you would need to check for a null parameter and behave differently. You should also explain this in the documentation. For example, doSomething() could be written as:

/**
  * @param obj An optional foo for ____. May be null, in which case
  *  the result will be ____.
  */
public void doSomething(SomeObject obj) {
    if(obj == null) {
       // Do something
    } else {
       // Do something else
    }
}

What methods/tools can be used to determine the cause so that you stop the exception from causing the program to terminate prematurely?

Now Java 14 has added a new language feature to show the root cause of NullPointerException. This language feature has been part of SAP commercial JVM since 2006.

In Java 14, the following is a sample NullPointerException Exception message:

in thread "main" java.lang.NullPointerException: Cannot invoke "java.util.List.size()" because "list" is null

answered Jan 10


In Java, the java.lang.NullPointerException is thrown when a reference variable is accessed (or de-referenced) and is not pointing to any object. This error can be resolved by using a try-catch block or a if-else condition to check if a reference variable is null before dereferencing it.

In some cases, the compiler prevents this exception with the compile-time error “The variable might not have been initialized” when a null a reference variable is passed as an argument of a method:

String s;
foo(s);  // Compiler gives an error.

However, the compiler does not give this error when null is directly passed to a function; ​however, there is a higher chance of it throwing a NullPointerException:

foo(null);  // Higher probability of an exception

Solution

public class NullPointerExcept {
	public static void main(String[] args) {
		String s = "abcd";

		foo(null);
		bar(null);
	}

	// Using a try-catch block:
	static void foo(String x){
		try {
			System.out.println("First character: " + x.charAt(0));
		}
		catch(NullPointerException e) {
			System.out.println("NullPointerException thrown!");
		}
	}

	// Using if-else condition:
	static void bar(String x){
		if(x != null)
			System.out.println("First character: " + x.charAt(0));
		else
			System.out.println("NullPointerException thrown!");
	}
}

answered Jan 10


In Java, the java.lang.NullPointerException is thrown when a reference variable is accessed (or de-referenced) and is not pointing to any object. This error can be resolved by using a try-catch block or an if-else condition to check if a reference variable is null before dereferencing it.,However, the compiler does not give this error when null is directly passed to a function; ​however, there is a higher chance of it throwing a NullPointerException:, In some cases, the compiler prevents this exception with the compile-time error “The variable might not have been initialized” when a null reference variable is passed as an argument of a method:

In some cases, the compiler prevents this exception with the compile-time error “The variable might not have been initialized” when a null a reference variable is passed as an argument of a method:

String s;
foo(s); // Compiler gives an error.

However, the compiler does not give this error when null is directly passed to a function; ​however, there is a higher chance of it throwing a NullPointerException:

foo(null); // Higher probability of an exception
public class NullPointerExcept {
   public static void main(String[] args) {
      String s = "abcd";

      foo(null);
      bar(null);
   }

   // Using a try-catch block:
   static void foo(String x) {
      try {
         System.out.println("First character: " + x.charAt(0));
      } catch (NullPointerException e) {
         System.out.println("NullPointerException thrown!");
      }
   }

   // Using if-else condition:
   static void bar(String x) {
      if (x != null)
         System.out.println("First character: " + x.charAt(0));
      else
         System.out.println("NullPointerException thrown!");
   }
}

answered Jan 10


Put Safety Checks Around Code That May Cause Null Pointer Exception

If you know the line of code that is causing your NullPointer and believe your logic is correct as well, you can wrap the section of code in a try-catch block, and define the behavior for when a Null Pointer is caught. This is how such a set-up will look like:

...
// Some code above

try {
  // Put the exception-prone code here
} catch (NullPointerException npe) {
  // Define what needs to be done when an NPE is caught
}

// Some code below
...

This happens in situations where a certain reference variable may or may not contain null. More often than not, remote API responses, device interface responses are prone to this scenario. Depending upon the availability of a result of hardware, the response variable may or may not point to an instantiated object. Using safety checks is best-suited to handle these situations.

answered Jan 10


Login and Submit Your Answer
Browse other questions tagged  java  nullpointerexception or ask your own question.