Why can this way of writing "aa".equals(a) avoid null pointers?

public static void main(String[] args) {

	String a=null;	if("aa".equals(a))//这种情形，不出现空指针异常
	//if(a.equals("aa"))//出现空指针异常
	{
	System.out.println(true);
	}	else {
	System.out.println(false);
	}
	}

Testing the two different comparison statements above, the null pointer exception does not occur in the first statement, but does occur in the second statement.
So when comparing variables and constants, the constants are generally put first. To avoid null pointer exception.
But my problem is: when the variable is in front, when the variable is read and the variable is empty, an exception occurs.
Why does the variable a no longer need to be read when the variable comes last? Since you want to compare and definitely read it, the question
is just a matter of order. Why does it not report a null pointer when it is placed at the end?

Regarding this issue before, when I was working in the company, I heard others say that this way of writing is to avoid null pointers. Indeed, I verified it and found that null pointers can be avoided. Later, when I wanted to delve deeper into the question I raised above, an old colleague told me that this also formed a programming standard. Thinking about the norms today, there are certain reasons.

This question came up in our technical exchange group today, and it made me think deeply.

So I made a post,

took a look at the equals method of the string class

public boolean equals(Object anObject) {
		 if (this == anObject) {
			 return true;
		 }
		 if (anObject instanceof String) {
			 String anotherString = (String) anObject;
			 int n = value.length;
			 if (n == anotherString.value.length) {
				 char v1[] = value;
				 char v2[] = anotherString.value;
				 int i = 0;
				 while (n-- != 0) {
					 if (v1[i] != v2[i])
							 return false;
					 i++;
				 }
				 return true;
			 }
		 }
		 return false;
	 }

But here comes my problem

I looked at the source code and I understand it, but if anobject is empty in the source code, Will there be no null pointer exception?
After some discussion later, I came to the conclusion like this.

The problem occurs in the calling method. Because the null value is not a String object. And you call the instance method of the String object through the declared String object reference. Of course not. nullThe method was called.

So the system reported a null pointer exception.

So, echoing the title of the article, this really avoids control needle abnormalities. After all, the form "aaa" is not null, and methods can be called. Then we can compare according to the equals method in the String class.

More Why can this way of writing "aa".equals(a) avoid null pointers. For related articles, please pay attention to the PHP Chinese website!