Null Object Pattern in Java

Back to: Java Design Patterns

Null Object Pattern in Java with Examples

In this article, I am going to discuss the Null Object Pattern in Java with Examples. Please read our previous article where we discussed the Template Method Design Pattern in Java with Examples. The Null Object Pattern falls under the category of Behavioral Design Pattern. In this article, we will explore the Null Object Design Pattern, its advantages, disadvantages, and its effective utilization in software development.

What is a Null Object Pattern?

In software development, dealing with null or undefined values is a common challenge that can lead to unexpected errors and bugs. The Null Object Design Pattern offers an elegant solution to this problem by providing a default implementation or behavior when a null or undefined object is encountered.

The Null Object Design Pattern addresses the scenario where an object’s absence or non-existence can lead to null references and subsequent runtime errors. The pattern aims to provide a null object that encapsulates a default behavior for the absent object, allowing the code to proceed without explicit null checks. The null object is an instance of a class that implements the same interface as the actual objects but provides a neutral or default behavior.

Implementing Null Object Pattern in Java:

A real-world example where the Null Object Design Pattern can be applied effectively is in a student management system. By utilizing the Null Object Design Pattern, a system can incorporate a null student as a default when a student’s data is unavailable. The null student object implements the same interface as the actual students but provides empty or neutral implementations for functions. Instead of implementing conditional checks throughout the codebase, developers can rely on the null object.

This approach offers several benefits. It eliminates the need for explicit null checks, simplifies the codebase, and reduces the risk of null pointer exceptions. It also provides a seamless integration with other students, as the null object adheres to the same interface. The UML Diagram of this example is given below using Null Object Design Pattern.

Step 1: Create a new directory to store all the class files of this project.

Step 2: Open VS Code and create a new project, called null.

Step 3: In the project, create a new file called AbstractStudent.java. Add the following code to the file:

public abstract class AbstractStudent
{
    protected String name;
    public abstract boolean isNull();
    public abstract String getName();
}

This is the abstract class from which other concrete classes will extend.

Step 4: In the project, create two new files called RealStudent.java and NullStudent.java. Both of these files extend from the AbstractStudent class. Add the following code to the files:

NullStudent.java

public class NullStudent extends AbstractStudent
{
    @Override
    public boolean isNull()         {return true;}
    @Override
    public String getName()         {return "N/A";}
}

RealStudent.java

public class RealStudent extends AbstractStudent
{
    @Override
    public boolean isNull()         {return false;}
    @Override
    public String getName()         {return name;}
    public RealStudent(String name) {this.name = name;}
}

Step 5: In the project, create a new file called StudentHandler.java. This class is responsible for working between the main class and the AbstractStudent class. Add the following code to StudentHandler.java:

public class StudentHandler
{
    public static AbstractStudent getStudent(String name)
    {
        String[] studentList = {"Student A", "Student B", "Student C"};

        for (int i = 0; i < studentList.length; i++)
        {
            if (name.equalsIgnoreCase(studentList[i])) 
                return new RealStudent(name);
        }
        
        return new NullStudent();
    }
}

Step 6: In the project, create a new file called NullPatternDemo.java. This class will contain the main() function. Add the following code to NullPatternDemo.java:

public class NullPatternDemo
{
    public static void main(String[] args)
    {
        //existing students
        AbstractStudent s1 = StudentHandler.getStudent("Student A");
        AbstractStudent s2 = StudentHandler.getStudent("Student B");
        AbstractStudent s3 = StudentHandler.getStudent("Student C");
        
        //non-existing students
        AbstractStudent s4 = StudentHandler.getStudent("Student D");

        System.out.println();
        System.out.println("Students: ");
        System.out.println(s1.getName());
        System.out.println(s2.getName());
        System.out.println(s3.getName());
        System.out.println(s4.getName());
    }   
}

This main() function tries to retrieve some students. If the students exist, an object of the type RealStudent is sent. Otherwise, an object of the type NullStudent is sent.

Step 7: Compile and execute the application. Ensure compilation is successful. Verify that the program works as expected.

Congratulations! You now know how to implement null object patterns!

UML Diagram of Null Object Design Pattern:

Now, let us see the Null Object Design Pattern UML Diagram Components with our Example so that you can easily understand the UML Diagram.

The classes can be described as follows:

1. Object: This is the abstract class that will define the basic methods that will be implemented by the concrete object class.
2. ConcreteObject: This class implements the Object abstract class. It implements the functions defined in the abstract class.
3. Handler: This class is responsible for communication between the main() function and objects of the class ConcreteObject.
4. DriverClass: This class contains the main() function and is responsible for the simulation of the program.

Advantages of Null Object Design Pattern in Java

The advantages of using the Null Object Design Pattern in Java are as follows:

• Elimination of Null Checks: One of the key advantages of the Null Object Design Pattern is the elimination of null checks throughout the codebase. Instead of checking for null values, developers can rely on the null object to provide a valid default behavior. This simplifies the code, improves readability, and reduces the risk of null pointer exceptions.
• Enhanced Robustness: By using the Null Object Design Pattern, developers can ensure that critical operations and methods can be safely invoked even when objects are missing or undefined. The null object encapsulates a behavior that prevents unexpected errors and allows the code to gracefully handle absent objects. This increases the overall robustness and stability of the system.
• Simplified Maintenance: The Null Object Design Pattern improves code maintainability by centralizing the default behavior within the null object itself. If changes are required in the default behavior, developers can make modifications solely in the null object class, without impacting the rest of the codebase. This reduces the risk of introducing bugs during maintenance and simplifies the process of evolving the system.
• Improved Testing: The presence of null objects simplifies unit testing. Since the null object provides a default behavior, developers can write test cases that cover different scenarios, including the absence of objects. This ensures more comprehensive test coverage and helps identify and fix potential issues related to null references or missing objects.
• Seamless Integration: The Null Object Design Pattern seamlessly integrates with existing codebases. By implementing the null object using the same interface as the actual objects, the pattern maintains compatibility with the existing code and avoids extensive changes or refactoring. This allows for a smooth transition to the null object pattern, enhancing code reusability and minimizing disruptions.

Disadvantages of Null Object Design Pattern in Java

The disadvantages of using the Null Object Design Pattern in Java are as follows:

• Increased Memory Consumption: The Null Object Design Pattern introduces additional objects into the system, even when objects are absent. While these null objects are lightweight and optimized, they still consume memory. In situations where memory usage is a critical concern, the overhead of null objects may become a disadvantage.
• Potential Behaviour Confusion: The default behavior provided by null objects might not always align with the expectations of the application or the developer. In certain cases, the neutral behavior of the null object may lead to subtle bugs or incorrect results. It is crucial to carefully design and define the default behavior to avoid such confusion.
• Limited Context-Specific Behaviour: The null object offers a generic or neutral behavior that applies to all scenarios where an object is missing. However, there may be situations where different behaviors are required based on the context or specific conditions. The null object pattern may not be suitable for scenarios that demand highly context-specific actions or dynamic behavior.
• Potential Performance Impact: Although null objects are designed to be lightweight, there may be a slight performance impact due to the additional method invocations and object instantiations. In performance-critical systems or scenarios with a high number of null object invocations, this overhead may become a concern.

In the next article, I am going to discuss Visitor Design Pattern in Java with Examples. Here, in this article, I try to explain Null Object Pattern in Java with Examples. I hope you understood the need for and use of the Null Object Pattern in Java.