Null checks

Java code - and not only it - tends to be littered with null reference checks like:

void foo(SomeClass obj) {
    if(obj != null) {
        obj.doSomething();
    }
}

While there are many legitimate cases for such code, quite often this code is a bad idea.

The essential question to ask with such code is: is a null value for the variable (parameter) a known possiblity with well-defined semantic, or is the if statement there just to prevent a NullPointerException (or similar for other languages).

If it is the first case, fine. Just make sure the code handles correctly whatever the meaning of a null pointer/reference is.

In the other case, it means that the pointer/reference is never supposed to be null, and it is a bug somewhere if the pointer/reference is null. In such a case, the if statement does several wrong things:

it clutters the code, making it less readable;

it makes less clear what the intention of the code is, and what are the preconditions for the function or the code assumptions in general;

if that pointer really comes in null, it hides (postpones) the error instead of (noisily) throw a NullPointerException.

What to do instead? Well:

Use @Nonnull annotation (or whatever is available in the programming language used) to mark it clear for the reader what the expectations are;
If the pointer/reference really comes in null, just let the NullPointerException happen. There is usually nothing better to do: without careful failure modes analysis, it is quite unlikely to write a code that positively makes less damage. The most likely effect of the if statement is to hide the error until a later time, with unpredictable damages to various data strucures and making debugging more difficult.