#590 explanation for Null Object

null-object/README.md

@@ -18,6 +18,143 @@ implements the expected interface, but whose method body is empty. The
 advantage of this approach over a working default implementation is that a Null
 Object is very predictable and has no side effects: it does nothing.
 
+## Explanation
+
+Real world example
+
+> We are building a binary tree from nodes. There are ordinary nodes and "empty" nodes. Traversing the tree normally should not cause errors, so we use null object pattern where necessary.            
+
+In plain words
+
+> Null Object pattern handles "empty" objects gracefully.   
+
+Wikipedia says
+
+> In object-oriented computer programming, a null object is an object with no referenced value or with defined neutral ("null") behavior. The null object design pattern describes the uses of such objects and their behavior (or lack thereof).
+
+**Programmatic Example**
+
+Here's the definitions for node interface and its implementations.
+
+```java
+public interface Node {
+
+  String getName();
+
+  int getTreeSize();
+
+  Node getLeft();
+
+  Node getRight();
+
+  void walk();
+}
+
+public class NodeImpl implements Node {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(NodeImpl.class);
+
+  private final String name;
+  private final Node left;
+  private final Node right;
+
+  /**
+   * Constructor.
+   */
+  public NodeImpl(String name, Node left, Node right) {
+    this.name = name;
+    this.left = left;
+    this.right = right;
+  }
+
+  @Override
+  public int getTreeSize() {
+    return 1 + left.getTreeSize() + right.getTreeSize();
+  }
+
+  @Override
+  public Node getLeft() {
+    return left;
+  }
+
+  @Override
+  public Node getRight() {
+    return right;
+  }
+
+  @Override
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public void walk() {
+    LOGGER.info(name);
+    if (left.getTreeSize() > 0) {
+      left.walk();
+    }
+    if (right.getTreeSize() > 0) {
+      right.walk();
+    }
+  }
+}
+
+public final class NullNode implements Node {
+
+  private static NullNode instance = new NullNode();
+
+  private NullNode() {
+  }
+
+  public static NullNode getInstance() {
+    return instance;
+  }
+
+  @Override
+  public int getTreeSize() {
+    return 0;
+  }
+
+  @Override
+  public Node getLeft() {
+    return null;
+  }
+
+  @Override
+  public Node getRight() {
+    return null;
+  }
+
+  @Override
+  public String getName() {
+    return null;
+  }
+
+  @Override
+  public void walk() {
+    // Do nothing
+  }
+}
+
+```
+
+Then we can construct and traverse the binary tree without errors as follows.
+
+```java
+    Node root =
+        new NodeImpl("1", new NodeImpl("11", new NodeImpl("111", NullNode.getInstance(),
+            NullNode.getInstance()), NullNode.getInstance()), new NodeImpl("12",
+            NullNode.getInstance(), new NodeImpl("122", NullNode.getInstance(),
+            NullNode.getInstance())));
+    root.walk();
+    
+    // 1
+    // 11
+    // 111
+    // 12
+    // 122
+```
+
 ## Class diagram
 ![alt text](./etc/null-object.png "Null Object")