When to Use Null Checks, Assertions, Exceptions, and the Null Object Pattern in Java

Many Java projects accumulate repetitive null‑checking code, which makes the codebase ugly and hard to maintain.

The core answer separates two situations: (1) null is a meaningful, valid return value, and (2) null indicates an invalid or erroneous condition.

In the second case, the recommended approaches are to use assert statements with explanatory messages or to throw a NullPointerException (or a custom exception) immediately, treating null as an illegal argument.

In the first case, null often represents an empty result (e.g., a database query returning no rows). The advice is to return an empty collection instead of null, or to return an empty object using the Null Object pattern.

Example of returning an empty collection:

public List
findItems(...) {
    return Collections.emptyList();
}

Example of 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 action */) {
            return DO_NOTHING;
        }
        // return real action
    }
}

Using this pattern eliminates the need for repetitive null checks; callers can safely invoke methods on the returned object.

Comparing two calling styles illustrates the benefit: the verbose version checks for null before each call, while the concise version directly chains calls because the Null Object guarantees a non‑null result.

Additional tips include preferring "value".equals(variable) to avoid NPE, using Java 8/Guava Optional to encapsulate possible nulls, and reconsidering whether a method should return null at all.