Design pattern

Eliminates explicit null checks by supplying a default no‑op implementation.

Web services: optional dependency may be absent; Game development: missing component should not break the update loop; Data processing: iterating over optional handlers without risking NoneType errors

Object‑oriented applications, Java/C#/Python projects, UI frameworks, game engines, microservice architectures

Define a neutral implementation → inject where a real implementation may be absent

• dependency injection
• strategy pattern
• polymorphic interface
• default implementation

• Use conditional null checks – simpler but adds branching
• Use language‑level optional types – safer but requires language support
• Use default arguments – limited to simple values

Implementing Null Object with empty methods that should return a value → leads to silent data loss; Forgetting to register the Null Object in a factory → real object still receives None; Overusing Null Object for complex behavior → masks design flaws and makes debugging harder

Strategy pattern – selects behavior at runtime, Null Object provides a do‑nothing behavior; Optional type – enforces presence or explicit absence, Null Object hides absence; Default object – similar but may carry default state, Null Object should be stateless

Coming from Python: may rely on "if obj is None" checks instead of a Null Object → ensure the Null Object subclass implements all required methods; Coming from JavaScript: using "null" as a sentinel can be confused with "undefined" – prefer a dedicated Null Object class

• Strategy pattern
• Null Object
• Optional type
• Default object

Do not use when the absent case requires distinct handling – a Null Object may hide needed error reporting; It adds negligible runtime overhead but introduces an extra class; Ensure the Null Object does not maintain mutable state, otherwise side effects can appear unexpectedly

Reduces conditional branching, prevents null‑reference crashes, and makes code paths uniform, improving maintainability and testability.

Think of a Null Object as a placeholder employee who shows up to work but never performs any task – the office keeps running without extra checks.

A well‑designed Null Object should implement all interface methods and return sensible defaults without side effects.

After mastering Null Object, move to the Strategy pattern for interchangeable behaviors.