How to Avoid Excessive Null Checks in Java: Best Practices and the Null Object Pattern

To avoid null‑pointer calls, developers often write code like:

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

Such repetitive null‑checking leads to bulky, hard‑to‑maintain code. The article examines why this happens and how to reduce it.

Key insight: Beginners frequently return null from methods, forcing callers to add null checks. This habit stems from treating every return value as untrustworthy.

Before adding a null check, distinguish two situations:

null is a valid response according to the method contract.

null indicates an invalid or erroneous condition.

Case 2 – Invalid parameter: When null is not a legitimate argument (e.g., a required API parameter), the method should fail fast by using an assert statement or throwing a NullPointerException (or a custom exception) to inform the caller.

Case 1 – Valid response: When null legitimately represents “no data” (e.g., a database query returns nothing), adopt the following practices:

If the return type is a collection, return an empty collection instead of null so callers can safely invoke methods like size() without extra checks.

If the return type is not a collection, return a neutral “empty” object rather than null . The Null Object pattern is a common solution.

Example of using the Null Object pattern:

public interface Action {
    void doSomething();
}

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

Without the pattern, findAction may return null , leading to a null‑pointer when doSomething() is called.

public class MyParser implements Parser {
    private static Action DO_NOTHING = new Action() {
        public void doSomething() { /* do nothing */ }
    };

    public Action findAction(String userInput) {
        // ...
        if (/* cannot find any actions */) {
            return DO_NOTHING;
        }
        // return actual action
    }
}

Comparison of usage:

1. Redundant null checks:

Parser parser = ParserFactory.getParser();
if (parser == null) {
    // handle error
}
Action action = parser.findAction(someInput);
if (action == null) {
    // do nothing
} else {
    action.doSomething();
}

2. Concise usage with Null Object:

ParserFactory.getParser().findAction(someInput).doSomething();

Additional recommendations from other answers:

When using equals , place the constant first to avoid NullPointerException (e.g., "bar".equals(foo) ).

Java 8 and Guava provide Optional to encapsulate potentially absent values, reducing explicit null checks.

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

Reference: http://stackoverflow.com/questions/271526/avoiding-null-statements-in-java?page=2&tab=votes#tab-top