What is null
?
Is null
an instance of anything?
What set does null
belong to?
How is it represented in the memory?
Is null an instance of anything?
No, there is no type which null
is an instanceof
.
instanceof
RelationalExpression: RelationalExpression instanceof ReferenceType
At run time, the result of the
instanceof
operator istrue
if the value of the RelationalExpression is notnull
and the reference could be cast to the ReferenceType without raising aClassCastException
. Otherwise the result isfalse
.
This means that for any type E
and R
, for any E o
, where o == null
, o instanceof R
is always false
.
What set does 'null' belong to?
There is also a special null type, the type of the expression
null
, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. Thenull
reference is the only possible value of an expression of null type. Thenull
reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend thatnull
is merely a special literal that can be of any reference type.
What is null?
As the JLS quote above says, in practice you can simply pretend that it's "merely a special literal that can be of any reference type".
In Java, null == null
(this isn't always the case in other languages). Note also that by contract, it also has this special property (from java.lang.Object
):
public boolean equals(Object obj)
For any non-
null
reference valuex
,x.equals(null)
shouldreturn false
.
It is also the default value (for variables that have them) for all reference types:
- Each class variable, instance variable, or array component is initialized with a default value when it is created:
- For all reference types, the default value is
null
.
How this is used varies. You can use it to enable what is called lazy initialization of fields, where a field would have its initial value of null
until it's actually used, where it's replaced by the "real" value (which may be expensive to compute).
There are also other uses. Let's take a real example from java.lang.System
:
public static Console console()
Returns: The system console, if any, otherwise
null
.
This is a very common use pattern: null
is used to denote non-existence of an object.
Here's another usage example, this time from java.io.BufferedReader
:
public String readLine() throws IOException
Returns: A
String
containing the contents of the line, not including any line-termination characters, ornull
if the end of the stream has been reached.
So here, readLine()
would return instanceof String
for each line, until it finally returns a null
to signify the end. This allows you to process each line as follows:
String line;
while ((line = reader.readLine()) != null) {
process(line);
}
One can design the API so that the termination condition doesn't depend on readLine()
returning null
, but one can see that this design has the benefit of making things concise. Note that there is no problem with empty lines, because an empty line "" != null
.
Let's take another example, this time from java.util.Map<K,V>
:
V get(Object key)
Returns the value to which the specified key is mapped, or
null
if this map contains no mapping for the key.If this map permits
null
values, then a return value ofnull
does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key tonull
. ThecontainsKey
operation may be used to distinguish these two cases.
Here we start to see how using null
can complicate things. The first statement says that if the key isn't mapped, null
is returned. The second statement says that even if the key is mapped, null
can also be returned.
In contrast, java.util.Hashtable
keeps things simpler by not permitting null
keys and values; its V get(Object key)
, if returns null
, unambiguously means that the key isn't mapped.
You can read through the rest of the APIs and find where and how null
is used. Do keep in mind that they aren't always the best practice examples.
Generally speaking, null
are used as a special value to signify:
How is it represented in the memory?
In Java? None of your concern. And it's best kept that way.
null
a good thing?This is now borderline subjective. Some people say that null
causes many programmer errors that could've been avoided. Some say that in a language that catches NullPointerException
like Java, it's good to use it because you will fail-fast on programmer errors. Some people avoid null
by using Null object pattern, etc.
This is a huge topic on its own, so it's best discussed as answer to another question.
I will end this with a quote from the inventor of null
himself, C.A.R Hoare (of quicksort fame):
I call it my billion-dollar mistake. It was the invention of the
null
reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in anull
reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.
The video of this presentation goes deeper; it's a recommended watch.