Avoiding Null Pointer Checks: When to Use Null, Assertions, and the Null Object Pattern

Hello, I am a senior architect. To avoid null‑pointer exceptions we often write code like if (someObject != null) { someObject.doCalc(); } , which leads to a lot of repetitive null checks.

Key Insight

Null handling can be split into two situations:

1. Null is a valid, meaningful return value.

2. Null is an invalid response and should be treated as an error.

Case 2 – Null as an Error

When a method receives an illegal null argument (e.g., a required API parameter), the method should abort and signal the problem, either by using an assert with a helpful message or by throwing a NullPointerException (or a custom exception).

Case 1 – Null as a Valid Value

If a query returns no data, returning null can express “empty”. However, it is often better to return an empty collection rather than null , allowing callers to operate safely without extra checks.

For non‑collection return types, return a neutral “empty object” instead of null . The Null Object pattern provides such an implementation.

Practical Code Examples

Typical null‑check:

if (someObject != null) {
    someObject.doCalc();
}

Interface definitions:

public interface Action {
    void doSomething();
}

public interface Parser {
    Action findAction(String userInput);
}

Null Object implementation:

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;
        }
        // otherwise return a real Action
    }
}

Calling code comparison:

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

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

Additional Tips

• Prefer constant‑first "bar".equals(foo) to avoid NPE when foo may be null.

• Java 8 and Guava provide Optional to wrap potentially null values.

• Consider throwing an exception instead of returning null when the situation represents an error.

The article also includes promotional notes about a “top architect” community and a giveaway, which are not part of the technical guidance.