Java.Lang.Nullpointerexception: Attempt to Invoke Virtual Method on a Null Object Reference

java.lang.NullPointerException: Attempt to invoke virtual method on a null object reference

Your app is crashing at:

welcomePlayer.setText("Welcome Back, " + String.valueOf(mPlayer.getName(this)) + " !");

because mPlayer=null.

You forgot to initialize Player mPlayer in your PlayGame Activity.

mPlayer = new Player(context,"");

Android Studio: NullPointerException: Attempt to invoke virtual method '...' on a null object reference

you have created an object of your DatabaseHelper class but you did not initialize that,
add this line in onCreate method

db=new DatabaseHelper(this);

after the setContentView

android studio: Attempt to invoke virtual method on a null object reference

Just note for future reference. Null pointer occurs if you access any method/variable of a class without initializing it. In a very naive version it happens whenever you do null.something.

So if you ever face null pointer on any line, check if you have anyway done null.something.

And a class reference is null till the point an object is not created. Usually an object creation line looks like

ClassName referenceName = new ClassName()

Where the part on the right hand side of = is creating the object which you can access using the reference name which is on the left hand side of = sign

What does java.lang.NullPointerException: Attempt to invoke virtual method '...' on a null object reference mean, and how do I solve it?

What is a NullPointerException?

First off, if you don't understand what null is, or what a NullPointerException means, take a look at What is a NullPointerException, and how do I fix it?. The rest of this answer will assume you've read that post.

How to investigate the cause

Now that you know the basics, you need to figure out what line your error is on. Take a look at What is a stack trace, and how can I use it to debug my application errors? for information on how to do that.

Once you know what line the error is on, the next thing you need to do is figure out what variable, exactly, is null. The error message will help you with that.

If your error looks like (the first ... may be either virtual or interface—it's not important which):

java.lang.NullPointerException: Attempt to invoke ... method 'ReturnTypeOfMethod package.name.SomeClass.someMethod(...)' on a null object reference

That means that the variable of type package.name.SomeClass on which you tried to call someMethod was null. It will also list the parameter types of the method, if any, where the (...) is in the example.

So, if you have this code:

MyClass myVariable = new MyClass();
String logMessage = "some other text: " + myVariable.toString() + someOtherVariable.method();

and you get this error message:

java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String com.mypackagename.MyClass.toString()' on a null object reference

You know that myVariable is null, because that's the only variable of type MyClass that had toString() called on it. The java.lang.String just means that toString() returns a String.

If the error is Attempt to read from field..., then apply the above advice, but looking for reading a field reference (MyClass.someProperty) rather than calling a method (MyClass.someMethod()).

If the error is Attempt to read from null array, look for anything on that line that reads from an array by index (for example, someArrayVariable[i]).

If the error is Attempt to get length of null array, look for a .length call on an array variable.

Common root causes and fixes

findViewById before setting up View in Activity/Fragment

One common problem is calling findViewById before the View is actually set up. For example, calling it in a member variable declaration:

public class MyActivity extends Activity {
    private Button submitButton = findViewById(R.id.submitButton);
    // ... rest of Activity code ...
}

or before setContentView:

public class MyActivity extends Activity {
    private Button submitButton;
    public void onCreate(Bundle savedInstanceState) {
        submitButton = findViewById(R.id.submitButton);
        setContentView(R.layout.activity_main);
    }
    // ... rest of Activity code ...
}

This doesn't work, because the findViewById is executed before you call setContentView in your onCreate method (for an Activity) or onCreateView (for a Fragment). To fix this, make sure you call it after setContentView. For Fragments, you can either put the code in onViewCreated, or ensure that you are calling it on the View returned from the LayoutInflater.inflate call.

Incorrect layout ID/view ID/view not in layout

The problem is sometimes that there is no view with the ID passed to findViewById in the given layout. Double check to make sure that your setContentView or LayoutInflater.inflate calls have the right layout ID (matches the XML filename) and that there is a View with that ID in that layout XML file (or one that it <include>s).

java.lang.NullPointerException: Attempt to invoke virtual method 'boolean java.util.Calendar.before(java.lang.Object)' on a null object reference

Try to reference to the Activity's field c in onTimeSet and onDateSet:

@Override
public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
    c = Calendar.getInstance();
    c.set(Calendar.HOUR_OF_DAY, hourOfDay);
    c.set(Calendar.MINUTE, minute);
    c.set(Calendar.SECOND, 0);
}

public void onDateSet(DatePicker view, int aasta, int kuu, int paev) {
    c = Calendar.getInstance();
    c.set(Calendar.YEAR, aasta);
    c.set(Calendar.MONTH, kuu);
    c.set(Calendar.DAY_OF_MONTH, paev);
}

So instead of Calendar c = Calendar.getInstance(); write c = Calendar.getInstance(); like in the code above.

---

Or you can try to initialize c property in Activity:

Calendar c = Calendar.getInstance();

and use it to change Calendar's properties, for example in onTimeSet method:

@Override
public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
    c.set(Calendar.HOUR_OF_DAY, hourOfDay);
    c.set(Calendar.MINUTE, minute);
    c.set(Calendar.SECOND, 0);
}

What is a NullPointerException, and how do I fix it?

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:

int 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:

Integer 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:

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() 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
    }
}

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:

class 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.}

---

Related Topics