There are two overarching types of variables in Java:

  1. Primitives: variables that contain data. If you want to manipulate the data in a primitive variable you can manipulate that variable directly. By convention primitive types start with a lowercase letter. For example variables of type int or char are primitives.

  2. References: variables that contain the memory address of an Object i.e. variables that refer to an Object. If you want to manipulate the Object that a reference variable refers to you must dereference it. Dereferencing usually entails using . to access a method or field, or using [ to index an array. By convention reference types are usually denoted with a type that starts in uppercase. For example variables of type Object are references.

Consider the following code where you declare a variable of primitive type int and don't initialize it:

Use with AIint x;
int y = x + x;

These two lines will crash the program because no value is specified for x and we are trying to use x's value to specify y. All primitives have to be initialized to a usable value before they are manipulated.

Now here is where things get interesting. Reference variables can be set to null which means "I am referencing nothing". You can get a null value in a reference variable if you explicitly set it that way, or a reference variable is uninitialized and the compiler does not catch it (Java will automatically set the variable to null).

If a reference variable is set to null either explicitly by you or through Java automatically, and you attempt to dereference it you get a NullPointerException.

The NullPointerException (NPE) typically 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. So you have a reference to something that does not actually exist.

Take the following code:

Use with AIInteger num;
num = new Integer(10);

The first line declares a variable named num, but it does not actually contain a reference value yet. Since you have not yet said what to point to, Java sets it to null.

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

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:

Use with AIpublic 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() method was called. Note, it is possible to call the method like this:

Use with AIdoSomething(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:

Use with AI// 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:

Use with AI/**
  * @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
    }
}

Finally, How to pinpoint the exception & cause using Stack Trace

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

Sonar with find bugs can detect NPE. Can sonar catch null pointer exceptions caused by JVM Dynamically

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

List of situations that cause a NullPointerException to occur

Here are all the situations in which a NullPointerException occurs, that are directly* mentioned by the Java Language Specification:

  • Accessing (i.e. getting or setting) an instance field of a null reference. (static fields don't count!)
  • Calling an instance method of a null reference. (static methods don't count!)
  • throw null;
  • Accessing elements of a null array.
  • Synchronising on null - synchronized (someNullReference) { ... }
  • Any integer/floating point operator can throw a NullPointerException if one of its operands is a boxed null reference
  • An unboxing conversion throws a NullPointerException if the boxed value is null.
  • Calling super on a null reference throws a NullPointerException. If you are confused, this is talking about qualified superclass constructor invocations:
Use with AIclass Outer {
    class Inner {}
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner(Outer o) { 
        o.super(); // if o is null, NPE gets thrown
    }
}
  • Using a for (element : iterable) loop to loop through a null collection/array.

  • switch (foo) { ... } (whether its an expression or statement) can throw a NullPointerException when foo is null.

  • foo.new SomeInnerClass() throws a NullPointerException when foo is null.

  • Method references of the form name1::name2 or primaryExpression::name throws a NullPointerException when evaluated when name1 or primaryExpression evaluates to null.

    a note from the JLS here says that, someInstance.someStaticMethod() doesn't throw an NPE, because someStaticMethod is static, but someInstance::someStaticMethod still throw an NPE!

* Note that the JLS probably also says a lot about NPEs indirectly.

🌐
GeeksforGeeks
geeksforgeeks.org › java › null-pointer-exception-in-java
Null Pointer Exception in Java - GeeksforGeeks
September 8, 2026 - Can occur while invoking methods, accessing fields, or using arrays. Helps identify improper object initialization or missing assignments. Can be prevented using null checks or Objects.requireNonNull().
🌐
Sentry
sentry.io › sentry answers › java › avoiding `nullpointerexception` in java
Avoid NullPointerException in Java with Null Checks | Sentry
October 1, 2026 - Prevent Java NullPointerException errors with null checks before method calls, using primitives where possible, and static analysis tools like NullAway
Discussions

java - What is a NullPointerException, and how do I fix it? - Stack Overflow
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 progra... More on stackoverflow.com
🌐 stackoverflow.com
How to avoid NullpointerException without null check in java - Stack Overflow
Remember, that trying to get (by get() method) the null element inside the Optional instance will result the NoSuchElementException immediately (but it's still unchecked exception) ... In Java if you want to avoid explicit null checks and still handle null values gracefully, you can use the ... More on stackoverflow.com
🌐 stackoverflow.com
How to avoid null pointer exception in java - Stack Overflow
You also must realise that in some cases null may be required and thus handling such an NPE would be different. If you are not going to actually do something with the Exception, it should not be caught as it's possibly harmful to catch an exception and then simply discard it. The following discusses when you ought to throw an exception or not - When to throw an exception? Upon further investigation, it seems that Java ... More on stackoverflow.com
🌐 stackoverflow.com
May 22, 2017
Eliminating Null Pointer Exceptions
IMO, the existence of null pointers in a memory safe language is contrary to its purpose. Null pointers are memory safety. They prevent you from doing the memory unsafe thing of referencing unintialized memory. More on reddit.com
🌐 r/java
91
0
June 24, 2024
🌐
Pluralsight
pluralsight.com › blog › software development
How to handle (and avoid) NullPointerExceptions in Java | Pluralsight
The practice of unit testing is also generally important and can come to your aid when preventing null pointers. For example, consider a test for Widget, our class from earlier, that ensures it is robust against null usage:
Top answer
1 of 12
4227

There are two overarching types of variables in Java:

  1. Primitives: variables that contain data. If you want to manipulate the data in a primitive variable you can manipulate that variable directly. By convention primitive types start with a lowercase letter. For example variables of type int or char are primitives.

  2. References: variables that contain the memory address of an Object i.e. variables that refer to an Object. If you want to manipulate the Object that a reference variable refers to you must dereference it. Dereferencing usually entails using . to access a method or field, or using [ to index an array. By convention reference types are usually denoted with a type that starts in uppercase. For example variables of type Object are references.

Consider the following code where you declare a variable of primitive type int and don't initialize it:

Use with AIint x;
int y = x + x;

These two lines will crash the program because no value is specified for x and we are trying to use x's value to specify y. All primitives have to be initialized to a usable value before they are manipulated.

Now here is where things get interesting. Reference variables can be set to null which means "I am referencing nothing". You can get a null value in a reference variable if you explicitly set it that way, or a reference variable is uninitialized and the compiler does not catch it (Java will automatically set the variable to null).

If a reference variable is set to null either explicitly by you or through Java automatically, and you attempt to dereference it you get a NullPointerException.

The NullPointerException (NPE) typically 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. So you have a reference to something that does not actually exist.

Take the following code:

Use with AIInteger num;
num = new Integer(10);

The first line declares a variable named num, but it does not actually contain a reference value yet. Since you have not yet said what to point to, Java sets it to null.

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

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:

Use with AIpublic 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() method was called. Note, it is possible to call the method like this:

Use with AIdoSomething(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:

Use with AI// 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:

Use with AI/**
  * @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
    }
}

Finally, How to pinpoint the exception & cause using Stack Trace

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

Sonar with find bugs can detect NPE. Can sonar catch null pointer exceptions caused by JVM Dynamically

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

List of situations that cause a NullPointerException to occur

Here are all the situations in which a NullPointerException occurs, that are directly* mentioned by the Java Language Specification:

  • Accessing (i.e. getting or setting) an instance field of a null reference. (static fields don't count!)
  • Calling an instance method of a null reference. (static methods don't count!)
  • throw null;
  • Accessing elements of a null array.
  • Synchronising on null - synchronized (someNullReference) { ... }
  • Any integer/floating point operator can throw a NullPointerException if one of its operands is a boxed null reference
  • An unboxing conversion throws a NullPointerException if the boxed value is null.
  • Calling super on a null reference throws a NullPointerException. If you are confused, this is talking about qualified superclass constructor invocations:
Use with AIclass Outer {
    class Inner {}
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner(Outer o) { 
        o.super(); // if o is null, NPE gets thrown
    }
}
  • Using a for (element : iterable) loop to loop through a null collection/array.

  • switch (foo) { ... } (whether its an expression or statement) can throw a NullPointerException when foo is null.

  • foo.new SomeInnerClass() throws a NullPointerException when foo is null.

  • Method references of the form name1::name2 or primaryExpression::name throws a NullPointerException when evaluated when name1 or primaryExpression evaluates to null.

    a note from the JLS here says that, someInstance.someStaticMethod() doesn't throw an NPE, because someStaticMethod is static, but someInstance::someStaticMethod still throw an NPE!

* Note that the JLS probably also says a lot about NPEs indirectly.

2 of 12
972

NullPointerExceptions are exceptions that occur when you try to use a reference that points to no location in memory (null) as though it were referencing an object. Calling a method on a null reference or trying to access a field of a null reference will trigger a NullPointerException. These are the most common, but other ways are listed on the NullPointerException javadoc page.

Probably the quickest example code I could come up with to illustrate a NullPointerException would be:

Use with AIpublic class Example {

    public static void main(String[] args) {
        Object obj = null;
        obj.hashCode();
    }

}

On the first line inside main, I'm explicitly setting the Object reference obj equal to null. This means I have a reference, but it isn't pointing to any object. After that, I try to treat the reference as though it points to an object by calling a method on it. This results in a NullPointerException because there is no code to execute in the location that the reference is pointing.

(This is a technicality, but I think it bears mentioning: A reference that points to null isn't the same as a C pointer that points to an invalid memory location. A null pointer is literally not pointing anywhere, which is subtly different than pointing to a location that happens to be invalid.)

🌐
How to do in Java
howtodoinjava.com › home › exception handling › java nullpointerexception: how to fix and avoid it
Java NullPointerException: How to Fix and Avoid It
October 10, 2026 - Fix a Java NullPointerException: read the helpful NPE message, see the common causes, and avoid NPEs with requireNonNull, Optional, defaults and JSpecify.
🌐
Snyk
snyk.io › blog › how-to-prevent-nullpointerexceptions-in-java
How to prevent NullPointerExceptions in Java | Snyk
September 21, 2023 - This approach is important for preventing potential NullPointerExceptions by checking for null values at runtime and throwing an exception if null values are encountered. When using interfaces, provide default methods to handle potential null objects, thus avoiding NullPointerExceptions:
🌐
Javatpoint
javatpoint.com › how-to-avoid-null-pointer-exception-in-java
How to avoid null pointer exception in Java - Javatpoint
How to avoid null pointer exception in Java with java tutorial, features, history, variables, object, programs, operators, oops concept, array, string, map, math, methods, examples etc.
Find elsewhere
🌐
Rollbar
rollbar.com › home › how to catch and fix nullpointerexception in java
How to Catch and Fix NullPointerException in Java
June 30, 2026 - NullPointerExceptions are among the most common runtime errors in production Java applications. A single uncaught NPE can crash user sessions and create poor user experiences. The prevention techniques above, especially defensive null checking, can eliminate the majority of these issues before they reach production. But when exceptions do slip through, having the right monitoring tool makes all the difference.
Top answer
1 of 2
4

Other than catching the error, if you are going to work with something which might be null, you might want to throw in null checks.

What you could do to reduce the chances of having to make null checks, would be to never return null from your methods, unless it is really necessary, for instance:

public IList<String> getUserNames()
{
     //No usernames found...
     return new ArrayList<String>();

     //As opposed to returning null
     return null;
}

By returning the empty list, a call to the above code would result into something like so: for(String name : this.getUserNames()) {...}. If no user names where found, the loop will not execute.

If on the other hand, you return null, you would need to do something like so:

List<String> userNames = this.getUsernames();
if(userNames != null)
     for(String userName : userNames) {....}
2 of 2
4

Could you elaborate on what you mean be avoiding NPEs? It can be done in many ways. In your case you shouldn't be passing null into your String.

A general rule that has been taught to me by fellow SO users is to always catch NPEs as early as possible (to avoid collateral damage throughout your application).

For parameter validation you'll most probably need to use Objects#requireNonNull.

You may also declare a simple if-statement depending on the scenario, like so - if (name != null)


You also must realise that in some cases null may be required and thus handling such an NPE would be different. If you are not going to actually do something with the Exception, it should not be caught as it's possibly harmful to catch an exception and then simply discard it. The following discusses when you ought to throw an exception or not - When to throw an exception?


Upon further investigation, it seems that Java 1.8 also offers a new Optional class ( java.util.Optional ) which seems very useful and cleaner. Take a look at this Oracle document.

🌐
Sentry
sentry.io › sentry answers › java › what is a nullpointerexception, and how do i fix it?
Java NullPointerException: Common Causes and How to Fix | Sentry
September 21, 2026 - Fix a NullPointerException by adding null checks before calling methods on objects, using constant-first comparisons and defensive validation of user input
🌐
Software Testing Help
softwaretestinghelp.com › home › java › what is nullpointerexception in java & how to avoid it
What Is NullPointerException In Java & How To Avoid It
April 1, 2025 - First, we must ensure that the objects that we use in our programs are initialized properly so that we can avoid the use of null objects that result in a Null Pointer Exception. We should also take care that the reference variables used in the ...
🌐
Medium
medium.com › @TechiesSpot › java-null-pointer-exception-causes-solutions-best-practices-and-key-points-80f4bd91a302
Java Null Pointer Exception: Causes, Solutions, Best Practices, and Key Points | by Techie's Spot | Medium
January 22, 2024 - Null Pointer Exceptions (NPE) are a prevalent issue in Java programming. They occur when you attempt to access a method or field on an object that is null, meaning it doesn’t reference any actual instance of an object.
🌐
Medium
medium.com › @gurkanucar › how-to-prevent-null-pointer-exceptions-in-java-8d7c894c9bb4
How to Prevent Null Pointer Exceptions in Java? | by Gürkan UÇAR | Medium
June 8, 2024 - Using optional, we can chaining properties with map and safely retrieve what we need without worrying about NullPointerException. String address = Optional.ofNullable(customer) .map(Customer::getMainAddress) .map(Address::getPostalAddress) ...
🌐
Medium
lakshya-bansal.medium.com › tips-to-avoid-nullpointerexception-in-java-c79736b9cac1
Tips to Avoid NullPointerException in Java | by Lakshya Bansal | Medium
October 7, 2024 - By understanding where null references could occur, you can avoid introducing null values that shouldn’t be. Java introduced the Optional class to handle nullable objects more gracefully.
🌐
freeCodeCamp
freecodecamp.org › news › how-to-handle-nullpointerexception-in-java
How to Handle NullPointerException in Java
July 13, 2020 - This can be done with a bunch of null check statements as well. But using Lombok helps us avoid writing multiple null check statements and makes the code look much cleaner.
🌐
javaspring
javaspring.net › blog › null-pointer-exception-java
Understanding and Handling Null Pointer Exceptions in Java — javaspring.net
Avoid Catching NullPointerException: Catching NullPointerException should be avoided as much as possible. Instead, prevent the exception from occurring in the first place by following the practices mentioned above. Catching NullPointerException can hide bugs in your code and make it harder to debug.
🌐
Blogger
javarevisited.blogspot.com › 2013 › 05 › ava-tips-and-best-practices-to-avoid-nullpointerexception-program-application.html
Java Tips and Best practices to avoid NullPointerException in Java Applications
null!=Object,; Object!=null ; which one throws null pointer exception ... Anonymous said... Java 8 has added a class called Optional which will make null handling and avoiding null pointer exception more easy.
🌐
DEV Community
dev.to › sharmaprash › what-is-a-nullpointerexception-and-how-do-i-fix-it-1j3i
What is a NullPointerException, and how do I fix it? - DEV Community
November 21, 2024 - When a NullPointerException is thrown, the JVM provides a stack trace pointing to the exact line where the exception occurred. Examine the line and identify the expression that evaluates to null. ... Look at MainClass.java:10 to identify the issue.