Facts about null in Java

Each and every programming language, including Java, is bounded with null. There is no programmer who didn't face any issue in the code related to null. Programmers mainly face NullPointerException when they try to perform some operations with null data. NullPointerException is a class available that belongs to java.lang package.

Before understanding the facts of null, it is required to have knowledge of Java variables. If you don't know what Java variable is, go through the following link:

Each and every developer should have knowledge about the following facts of null in Java:

Case Sensitive

In Java, we cannot write null as NULL or 0 as in C programming because null is a literal and keywords are case-sensitive in Java.

Let's take an example to understand the case-sensitive behaviour of null.

NullExample1.java

// import classes and packages if any
public class NullExample1
{
// main() method start
    	public static void main (String[] args) throws java.lang.Exception
    	{
        		// declare and initialize an object with NULL
        		Object obj1 = NULL; 
        		// declare and initialize an object with null
       	 	Object obj2 = null; 
		// print both objects
 		System.out.println("The value of obj1 is: "+obj1);
 		System.out.println("The value of obj2 is: "+obj2);
    	}
}

Output:

Reference Variable Value

By default, each and every reference variable has a null value in Java. A reference variable is used to indicate and store objects/values of reference type in Java. Classes, arrays, enumerations, and interfaces, etc., are some reference types in Java.

So, a reference type stores a null value if no object is passed to a reference type.

Let's take an example to understand how a reference variable works for null value:

NullExample2.java

// import classes and packages if any
public class NullExample2
{
 	// declare two objects
 	private static Object obj1;
 	private static Object obj2; 

 	// main() method start
    	public static void main (String[] args)
    	{

 		// print both objects
 		System.out.println("The value of obj1 is: "+obj1);
 		System.out.println("The value of obj2 is: "+obj2);

    	}
}

Output:

Null Type

In Java, null is neither an Object nor a type. It is a special value that we can assign to any reference type variable. We can cast null into any type in which we want, such as string, int, double, etc.

Let's take an example to understand how we can assign null values to any reference type.

NullExample3.java

// import classes and packages if any
public class NullExample3
{
// main() method start
    	public static void main (String[] args)
    	{
  		// pass a null value to a different type of variable
		// pass null to String
 		String str = null;
 		// pass null to Integer
 		Integer itr = null;
 		// pass null to Double
 		Double dbl = null;

 		// casting null to String
 		String castedStr = (String)null;

 		// casting null to Integer
 		Integer castedItr = (Integer)null;

 		// casting null to Double
 		Double castedDbl = (Double)null;

 		// print all reference type
  		System.out.println("The value of str is: "+str);
 		System.out.println("The value of itr is: "+itr);
 		System.out.println("The value of dbl is: "+dbl);
  		System.out.println("The value of castedStr is: "+castedStr);
 		System.out.println("The value of castedItr is: "+castedItr);
 		System.out.println("The value of castedDbl is: "+castedDbl);

    	}
}

Output:

Autoboxing and Unboxing

Autoboxing and Unboxing are the two most important operations which we perform in Java. The compiler throws NullPointerException when we assign a null value to any primitive boxed data type while performing the operations.

Let's take an example to understand autoboxing and the unboxing fact of null.

NullExample4.java

// import classes and packages if any
public class NullExample4
{
 	// main() method start
    	public static void main (String[] args) throws java.lang.Exception
    	{
        		// pass null value to a reference type
        		Integer itr = null; 

 		// perform unboxing operation
 		int data = itr;

 		// print both objects
 		System.out.println("The value of itr is: "+itr);
 		System.out.println("The value of data is: "+data);
    	}
}

Output:

The instanceof Operator

In order to check whether an object is an instance of the specified type or not, we use the instanceof operator. The instanceof operator returns true when the value of the expression is not null at run time. It plays an important role in typecasting checks.

Let's take an example to understand the instanceof operator:

NullExample5.java

// import classes and packages if any
public class 
{
 	// main() method start
    	public static void main (String[] args) throws java.lang.Exception
    	{
        		// pass null value to a reference type
        		Integer m = null; 
 		// pass a value to a reference type
 		Integer n = 20;
 		// print instanceof values
  		System.out.println(m instanceof Integer);
 	System.out.println(n instanceof Integer);

    	}
}

Output:

Static Vs. Non-static Methods

We cannot call a non-static method on a reference variable with a null value. If we call it, it will throw NullPointerException, but we can call the static method with reference variables with null values. Since, static methods are bonded using static binding, they won't throw Null pointer Exception.

Let's take an example to understand the fact of null:

NullExample6.java

// import classes and packages if any
public class NullExample6
{
// define static method
public static void staticMethod()
    	{
        		//it can be called by using a null reference
        		System.out.println("static method can be called by null reference.");
          
    	}
// define non static method
    	public void nonStaticMethod()
    	{
        		//it cannot be called by using a null reference
        		System.out.println("static method cannot be called by a null reference.");
    	}
// main() method start
    	public static void main (String[] args) throws java.lang.Exception
    	{
        		NullExample6 exp = null;
        		exp.staticMethod();
        		exp.nonStaticMethod();
    	}
}

Output:

== and != Operators

In Java, these two operators are allowed with null. Both the operators are useful in checking null with objects in Java.

Let's take an example to understand how these two operators work with null.

NullExample7.java

// import classes and packages if any
public class NullExample7
{
 	// main() method start
    	public static void main (String[] args)
    	{
 		// pass null value to String type of variables

 		// pass null to str1
 		String str1 = null;

 		// pass null to str2
  		String str2 = null;

  		// pass null to str3
  		String str3 = "Test";

 		// compare strings
 		if(str1 == str2){
  			System.out.println("str1 and str2 both are equal");
 		}else{
   			System.out.println("str1 and str2 are not equal");
 	}
   		if(str2 == str3){
  			System.out.println("str2 and str3 both are equal");
  		}else{
 		System.out.println("str2 and str3 are not equal");
 	}
 		if(str3 == str1){
 			System.out.println("str3 and str1 both are equal");
 	}else{
 			System.out.println("str3 and str1 are not equal");
 	}
    	}
}

Output: