WARNING 4! NPE when accessing index value of null array/collection
Consider the following code written by a client of ChainSaw:
ChainSaw myChainSaw = ChainSaw.initChainSaw(“QWE-T800”);
ChainSaw[] friendsChainSaw = new ChainSaw[]{
ChainSaw.initChainSaw(“Q22-T450”),
ChainSaw.initChainSaw(“QRT-T300”),
ChainSaw.initChainSaw(“Q-T900”),
null, // ops!
ChainSaw.initChainSaw(“QMM-T850”), // model is not supported
ChainSaw.initChainSaw(“ASR-T900”)
};
int score = myChainSaw.performance(friendsChainSaw);
Creating an array of ChainSaw was quite challenging in this example. We accidentally slip a null value (actually, we did it intentionally) and an unsupported model. In return, we get the following NPE:
Exception in thread “main” java.lang.NullPointerException: Cannot read field “speed” because “cs” is null
at modern.challenge.ChainSaw.performance(ChainSaw.java:37)
at modern.challenge.Main.main(Main.java:31)
The message informs us that the cs variable is null. This is happening at line 37 in ChainSaw, so in the for-loop of the performance() method. While looping the given array, our code iterated over the null value which doesn’t have the speed field. Pay attention to this kind of scenario: even if the given array/collection itself is not null, it doesn’t mean that it cannot contain null items. So, adding a guarding check before handling each item can save us for NPE in this case. Depending on the context, we can throw an IllegalArgumentException when the loop passes over the first null or simply ignore null values and don’t break the flow (in general, this is more suitable). Of course, using a collection that doesn’t accept null values is also a good approach (Apache Commons Collection and Guava have such collections).
WARNING 5! NPE when accessing a field via a getter
Consider the following code written by a client of ChainSaw:
ChainSaw cs = ChainSaw.initChainSaw(“T5A-T800”);
String power = cs.getPower();
System.out.println(power.concat(” Watts”));
And, the associated NPE:
Exception in thread “main” java.lang.NullPointerException: Cannot invoke “String.concat(String)” because “power” is null
at modern.challenge.Main.main(Main.java:37)
Practically, the getter getPower() returned null since the power field is null. Why that? The answer is in the line return new ChainSaw(model, null, (int) (Math.random() * 100)); of the initChainSaw() method. Because we didn’t decide yet on the algorithm for calculating the power of a chainsaw we passed null to the ChainSaw constructor. Further, the constructor simply set the power field as this.power = power. If it was a public constructor then most probably we have added some guarded conditions, but being a private constructor is better to fix the issue right from the root and not pass that null. Since the power is a String, we can simply pass an empty string or a suggestive string such as UNKNOWN_POWER. We also may leave a TODO comment in code as // TODO (JIRA ####): replace UNKNOWN_POWER with code. This will remind us to fix this in the next release. Meanwhile, the code has eliminated the NPE risk.Ok, after we fixed all these 5 NPE risks the code has become (the added code was highlighted):
public final class ChainSaw {
private static final String UNKNOWN_POWER = “UNKNOWN”;
private static final List<String> MODELS
= List.of(“T300”, “T450”, “T700”, “T800”, “T900”);
private final String model;
private final String power;
private final int speed;
public boolean started;
private ChainSaw(String model, String power, int speed) {
this.model = model;
this.power = power;
this.speed = speed;
}
public static ChainSaw initChainSaw(String model) {
if (model == null || model.isBlank()) {
throw new IllegalArgumentException(“The given model
cannot be null/empty”);
}
for (String m : MODELS) {
if (model.endsWith(m)) {
// TO DO (JIRA ####): replace UNKNOWN_POWER with code
return new ChainSaw(model, UNKNOWN_POWER,
(int) (Math.random() * 100));
}
}
throw new UnsupportedOperationException(
“Model ” + model + ” is not supported”);
}
public int performance(ChainSaw[] css) {
if (css == null) {
throw new IllegalArgumentException(
“The given models cannot be null”);
}
int score = 0;
for (ChainSaw cs : css) {
if (cs != null) {
score += Integer.compare(this.speed, cs.speed);
}
}
return score;
}
public void start() {
if (!started) {
System.out.println(“Started …”);
started = true;
}
}
public void stop() {
if (started) {
System.out.println(“Stopped …”);
started = false;
}
}
public String getPower() {
return power;
}
@Override
public String toString() {
return “ChainSaw{” + “model=” + model
+ “, speed=” + speed + “, started=” + started + ‘}’;
}
}
Done! Now, our code is NPE-free. At least until the reality will contradict us and a new NPE will occur :))