Java null Keyword
Usage and Examples

null Keyword in Java

In Java, null is a special literal that represents the absence of a value for a reference type. It is not a keyword in the strictest sense (like class or public), but a reserved literal used to denote that an object reference does not point to any memory location yet.

Why Do We Use null?

Java is a statically typed language, which means every variable must have a type. For object references (non-primitive types), the null value is a way to indicate "no object". This is crucial in many scenarios such as:

• Indicating uninitialized state
• Returning 'no result' from a method
• Resetting object references

Example: Assigning null to an Object

class Book {
    String title;
}

public class Main {
    public static void main(String[] args) {
        Book myBook = null; // myBook does not point to any Book object yet
        System.out.println(myBook); // prints: null
    }
}

null

Attempting to Access a null Reference

If you try to access members of a reference that is null, Java will throw a NullPointerException.

public class Main {
    public static void main(String[] args) {
        String text = null;
        System.out.println(text.length()); // Triggers NullPointerException
    }
}

Exception in thread "main" java.lang.NullPointerException
    at Main.main(Main.java:4)

How to Avoid NullPointerException

There are several ways to prevent runtime errors due to null values:

• Check if the reference is null before accessing it
• Use default object initialization
• Employ the Optional API (Java 8+)

Example: Safe Null Check

public class Main {
    public static void main(String[] args) {
        String message = null;

        if (message != null) {
            System.out.println(message.length());
        } else {
            System.out.println("The string is null");
        }
    }
}

The string is null

Returning null from a Method

public class UserService {
    public String findUserById(int id) {
        if (id == 1) return "Alice";
        return null;
    }

    public static void main(String[] args) {
        UserService service = new UserService();
        String user = service.findUserById(2);

        if (user != null) {
            System.out.println("User found: " + user);
        } else {
            System.out.println("User not found");
        }
    }
}

User not found

Assigning null to Arrays and Custom Objects

public class Main {
    public static void main(String[] args) {
        int[] numbers = null;
        String[] names = new String[3];
        names[0] = "John";
        names[1] = null; // Valid usage

        System.out.println(names[1]); // prints: null
    }
}

null

Comparing with null

Always use == or != when comparing a reference to null.

String data = null;

if (data == null) {
    System.out.println("Data is null");
}

Data is null

Using null with Wrapper Classes

Wrapper classes like Integer, Double, and Boolean can hold null, unlike primitive types.

public class Main {
    public static void main(String[] args) {
        Integer count = null;

        if (count == null) {
            System.out.println("No value assigned to count");
        }
    }
}

No value assigned to count

Summary: Key Takeaways

• null is used with reference types to indicate absence of a value.
• Accessing members of a null reference throws NullPointerException.
• Always perform null checks before accessing reference variables.
• Use default values or the Optional class to write safer code.

Practice Tip

Whenever you get a NullPointerException, check the exact line and trace back the reference variable. Most of the time, it’s a missed initialization.