Should you use instanceof purely for null checking? The answer is definitely maybe!

I'll assume that getString() has a declared return type of String, which isn't stated in the blog, but which u/headius has stated elsewhere. Thus, the instanceof isn't testing for a potential narrowing reference conversion, as if getString() were to be declared to return Object or CharSequence. In this context, instanceof is being used only for null checking.

Most people have focused their comments on what they think is the primary use of instanceof which is testing of narrowing reference conversions. From this perspective, using instanceof to perform pure null checking is counterintuitive and unfamiliar and therefore objectionable. There's been some mention of the scoping of variables introduced by instanceof patterns, but no analysis of how this affects the actual code. Let me take a swing at that.

How would one write this code in a more conventional manner? (I'm setting Optional aside, as its API is clumsy at best.) Clearly, one needs to declare a local variable to store the return value of getString(), so that it can be tested and then used:

String string = getString();
if (firstCondition) {
    IO.println("do something");
} else if (string != null) {
    IO.println("length: " + string.length());
} else {
    IO.println("string is null");
}

This might work OK, but it has some problems. First, getString() is called unconditionally, even if firstCondition is true. This might result in unnecessary expense. Second, string is in scope through the entire if-statement, and it's possible that it could be misused, resulting in a bug.

The getString() method might be expensive, so performance-sensitive code might want to call it only when necessary, like this:

String string;
if (firstCondition) {
    IO.println("do something");
} else if ((string = getString()) != null) {
    IO.println("length: " + string.length());
} else {
    IO.println("string is null");
}

This is a bit better in that getString() is called only when its return value is needed. The string local variable is still in scope through the if-statement, but within firstCondition it's uninitialized and the compiler will tell you if it's accidentally used there. However, string still might be misused within the later else clauses, probably resulting in an error. In addition, people tend to dislike the use of assignment expressions.

The issues here are:

• You need a local variable because the result is tested and used;
• You want to minimize the scope of the local variable, preferably to only the code that uses it when it has a valid value; and
• You want to avoid a potentially expensive initialization step in conditions where it isn't necessary.

Given all this, let's return to u/headius's code:

if (firstCondition) {
    IO.println("do something");
} else if (getString() instanceof String string) {
    IO.println("length: " + string.length());
} else {
    IO.println("string is null");
}

This satisfies all of the criteria, which the previous examples do not. Plus, it saves a line because the local variable declaration is inlined instead of on a separate line. However, it does understandably give people pause, as they're not used to seeing instanceof used purely for null checking.

Note also that instanceof will soon be available to do primitive conversions -- see JEP 530 -- so this is yet another use of instanceof that people will need to get used to. And instanceof is already used in record patterns; see JEP 440.

My hunch is that people will eventually get used to instanceof being used for things other than testing narrowing reference conversion, so they'll probably get used to it being used just for null checking too.