When and How to Use Null Checks in Java: Best Practices and Alternatives

In Java projects, developers often write repetitive null‑checking code like if (someObject != null) { someObject.doCalc(); } , which can lead to bloated and hard‑to‑maintain code bases.

The answer first separates two scenarios: (1) null is a meaningful, contract‑defined response, and (2) null indicates an error or invalid argument.

Scenario 2 – Null as an error

When a method receives an invalid argument (e.g., a required ID is missing), the method should abort early by throwing an exception or using an assert with a clear error message, rather than returning null.

Scenario 1 – Null as a valid value

If null legitimately represents “no data” (e.g., a database query returns no rows), the recommendation is to return an empty collection instead of null, allowing callers to safely call methods like list.size() without additional checks.

For non‑collection return types, the article suggests returning a “null object” that implements the expected interface but performs no operation. Example interfaces:

public interface Action {
    void doSomething();
}

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

Implementation using the Null Object pattern:

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

    public Action findAction(String userInput) {
        // ...
        if (/* we can't find any actions */) {
            return DO_NOTHING;
        }
        // return real action
    }
}

With this approach, client code can be simplified:

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

In contrast, the redundant style would require multiple null checks:

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

Additional tips include using "bar".equals(foo) to avoid NPEs when comparing strings, and leveraging Optional (Java 8/Guava) to encapsulate potentially absent values.

The article also contains community announcements and promotional links for ChatGPT services, a knowledge‑sharing group, and interview resources, but the core technical guidance focuses on reducing unnecessary null checks and applying defensive programming patterns.