Null Object pattern in LLD - System Design Exercise

Design: Null Object Pattern Implementation

Design the pattern structure and usage in a system to replace null references with Null Objects. Out of scope are specific language implementations or integration with large frameworks.

Functional Requirements

FR1: Provide a way to avoid null checks in client code when dealing with absent or missing objects

FR2: Ensure the system can handle operations on objects that may be null without throwing errors

FR3: Allow seamless substitution of a 'null object' that behaves like a real object but does nothing

FR4: Support easy extension to add new types of null objects for different classes

Non-Functional Requirements

NFR1: The pattern should not introduce significant performance overhead

NFR2: The design must be simple and easy to understand for developers

NFR3: The solution should be language-agnostic and applicable in low-level design

NFR4: Must maintain code readability and reduce conditional branching

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Abstract base class or interface defining common methods

Concrete real object classes implementing the interface

Null Object class implementing the interface with empty or default behavior

Client code that uses the interface without null checks

Design Patterns

Polymorphism to substitute Null Object for null references

Factory pattern to create real or null objects transparently

Dependency Injection to provide Null Objects where needed

Strategy pattern if behavior varies between real and null objects

Reference Architecture

Interface

↓

RealObject

Components

Interface

Abstract class or interface

Defines common methods for real and null objects

RealObject

Concrete class

Implements actual behavior for the interface

NullObject

Concrete class

Implements interface with empty or default behavior to avoid null checks

Client

Any

Uses the interface without null checks, relying on polymorphism

Request Flow

1. Client requests an object from a factory or service.

2. Factory returns either a RealObject or a NullObject implementing the interface.

3. Client calls methods on the returned object without checking for null.

4. If the object is RealObject, real behavior executes.

5. If the object is NullObject, safe default behavior executes (e.g., no operation).

6. Client continues without null pointer exceptions or conditional checks.

Database Schema

Not applicable for Null Object pattern as it is a design pattern focused on object behavior rather than data storage.

Scaling Discussion

Bottlenecks

Increased number of NullObject classes if many interfaces require null handling

Potential confusion if NullObject behavior is not clearly documented

Performance overhead if NullObject methods do unnecessary work

Difficulty in debugging when NullObject silently swallows operations

Solutions

Use generic NullObject implementations where possible to reduce class count

Document NullObject behavior clearly for developers

Keep NullObject methods minimal and efficient

Add logging or monitoring in NullObject methods to trace usage if needed

Interview Tips

Time: Spend 5 minutes explaining the problem of null references, 10 minutes describing the Null Object pattern structure and benefits, 5 minutes walking through a simple example, and 5 minutes discussing trade-offs and scaling.

Explain how Null Object pattern eliminates null checks and reduces errors

Describe the role of interface and polymorphism in the pattern

Show how client code becomes simpler and safer

Discuss when to use Null Object vs other approaches like Optional or exceptions

Mention potential pitfalls and how to mitigate them