Eliminate NullPointerExceptions with the Null Object Pattern and Optional

Null Check Disaster

Developers often litter code with repetitive null‑checks to avoid NullPointerException, leading to verbose and hard‑to‑maintain code.

One common approach is:

if (data != null) {
    // do something
}

When many objects are used repeatedly, the amount of null‑checking can explode, as shown by screenshots of thousands of lines.

Null Object Pattern

The Null Object pattern provides an object with neutral behavior instead of null, eliminating the need for explicit checks.

In object‑oriented programming, a null object is an object with no referenced value or with defined neutral ("null") behavior.

Typical implementation:

public interface Nullable {
    boolean isNull();
}

public interface DependencyBase extends Nullable {
    void Operation();
}

public class Dependency implements DependencyBase, Nullable {
    @Override
    public void Operation() {
        System.out.print("Test!");
    }
    @Override
    public boolean isNull() {
        return false;
    }
}

public class NullObject implements DependencyBase {
    @Override
    public void Operation() {
        // do nothing
    }
    @Override
    public boolean isNull() {
        return true;
    }
}

public class Factory {
    public static DependencyBase get(Nullable dependencyBase) {
        if (dependencyBase == null) {
            return new NullObject();
        }
        return new Dependency();
    }
}

public class Client {
    public void test(DependencyBase dependencyBase) {
        Factory.get(dependencyBase).Operation();
    }
}

This allows code to call methods without null checks.

NR Null Object Plugin

NR Null Object is an IntelliJ‑based plugin (supports Android Studio, IntelliJ IDEA, PhpStorm, WebStorm, PyCharm, RubyMine, AppCode, CLion, GoLand, DataGrip) that automatically generates the components required for the Null Object pattern.

Analyzes the selected class to declare interface methods.

Extracts a public interface.

Creates a null object implementing the interface.

Marks selected methods as nullable.

Allows incremental generation.

Applies automatic naming conventions.

Install via Preferences → Plugins → Browse repositories, search “NR Null Object”, install and restart the IDE.

Using Java 8 Optional

Java 8’s Optional provides a container that may hold a non‑null value, enabling fluent null‑safe chains.

public String testOptional(Test test) {
    return Optional.ofNullable(test)
            .flatMap(Test::getTest3)
            .flatMap(Test3::getTest2)
            .map(Test2::getInfo)
            .orElse("");
}

Key methods: ofNullable – wraps a value or returns an empty Optional. flatMap – applies a function returning Optional, avoiding nested Optionals. map – applies a function returning a plain value. orElse – provides a default when the Optional is empty.

Optional makes code concise but adds learning cost and may increase bytecode size; it requires Android API 24+.

Alternative: Guava

Guava’s Optional offers similar functionality and can be added via Gradle:

dependencies {
    compile 'com.google.guava:guava:27.0-jre'
    // or for Android:
    api 'com.google.guava:guava:27.0-android'
}

Kotlin Null‑Safety

Kotlin provides built‑in null‑safety with safe‑call operators:

test1?.test2?.test3?.test4

While Kotlin eliminates boilerplate, switching solely for null‑checks is not recommended.

Pros and Cons of Optional

Encapsulates defensive programming.

Enables fluent chaining.

Prevents NullPointerExceptions.

Drawbacks include limited popularity, extra learning curve, and IDE warnings on Android.