How to Eliminate Redundant Null Checks in Java with the Null Object Pattern

To avoid null pointer exceptions, developers often write repetitive null‑checking code, which can become ugly and unnecessary.

Key insight: Distinguish whether null is a valid response or an error condition.

When null indicates an invalid argument, the method should fail fast by throwing an exception or using an assert with a clear message.

When null is a legitimate “empty” value (e.g., a missing database record), prefer returning an empty collection or a dedicated empty object instead of null.

Practical recommendations:

Return an empty List (or other collection) rather than null.

If the return type is not a collection, return a well‑defined empty object.

Applying the Null Object pattern:

public interface Action {
    void doSomething();
}
public interface Parser {
    Action findAction(String userInput);
}
public class MyParser implements Parser {
    private static final Action DO_NOTHING = new Action() {
        public void doSomething() { /* do nothing */ }
    };
    public Action findAction(String userInput) {
        // …
        if (/* cannot find any actions */) {
            return DO_NOTHING;
        }
        // …
    }
}

Usage comparison:

// Redundant null checks
Parser parser = ParserFactory.getParser();
if (parser == null) { /* handle */ }
Action action = parser.findAction(input);
if (action == null) { /* do nothing */ } else { action.doSomething(); }

// Concise version
ParserFactory.getParser().findAction(input).doSomething();

Additional tips:

Prefer "constant".equals(variable) to avoid NPE.

Java 8’s Optional can encapsulate potentially null values, though it adds verbosity.

If a method must return null, consider throwing an exception instead.