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:

<code>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;
        }
        // …
    }
}
</code>

Usage comparison:

<code>// 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();
</code>

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.