Return to Answer

See also: What is a stack trace, and how can I use it to debug my application errors?

What about on Android?

On Android, tracking down the immediate cause of an NPE is a bit simpler. The exception message will typically tell you the (compile time) type of the null reference you are using and the method you were attempting to call when the NPE was thrown. This simplifies the process of pinpointing the immediate cause.

But on the flipside, Android has some common platform-specific causes for NPEs. A very common is when getViewById unexpectedly returns a null. My advice would be to search for Q&As about the cause of the unexpected null return value.

the statement labelled "HERE" is going to attempt to run the length() method on a null reference, and this will throw a NullPointerException.

Second observation: when I run the program, it outputs two lines of "gobbledy-gook". WRONG!! That's not gobbledy-gook. It is a stacktrace ... and it provides vital information that will help you track down the error in your code, if you take the time to read it carefully.

In short the stack trace will tell us unambiguously which statement of the program has thrown the NPE.

This is the hard part. The short answer is to apply logical inference to the evidence provided by the stack trace, the source code and the relevant API documentation.

In fact there is only one way: it can only happen if foo has the value null. We then try to run the length() method on null and .... BANG!

Well, if that happened, the stack trace would look different. The first "at" line would say that the exception was thrown in some line in the java.lang.String class, and line 4 of Test.java would be the second "at" line.

So where did that null come from? In this case it is obvious, and it is obvious what we need to do to fix it. (Assign a non-null value to foo.)

So what about our second scenario? Well, we can see that pos is 1, so that means that foo[1] must be null. Is that possible?

the statement labeled "HERE" is going to attempt to run the length() method on a null reference, and this will throw a NullPointerException.

Second observation: when I run the program, it outputs two lines of "gobbledy-gook". WRONG!! That's not gobbledy-gook. It is a stacktrace ... and it provides vital information that will help you track down the error in your code if you take the time to read it carefully.

In short, the stack trace will tell us unambiguously which statement of the program has thrown the NPE.

This is the hard part. The short answer is to apply logical inference to the evidence provided by the stack trace, the source code, and the relevant API documentation.

In fact, there is only one way: it can only happen if foo has the value null. We then try to run the length() method on null and... BANG!

Well, if that happened, the stack trace would look different. The first "at" line would say that the exception was thrown in some line in the java.lang.String class and line 4 of Test.java would be the second "at" line.

So where did that null come from? In this case, it is obvious, and it is obvious what we need to do to fix it. (Assign a non-null value to foo.)

So what about our second scenario? Well, we can see that pos is 1, so that means that foo[1] must be null. Is this possible?

    public class Test {
        public static void main(String[] args) {
            String foo = null;
            int length = foo.length();   // HERE
        }
    }

            int length = foo.length(); // HERE

    return args[pos].length();

    int length = test(foo, 1);
    

public class Test {
    public static void main(String[] args) {
        String foo = null;
        int length = foo.length();   // HERE
    }
}

int length = foo.length(); // HERE

return args[pos].length();

int length = test(foo, 1);