Improved 'instanceof' operator in Java 14

Marcin Zajączkowski — Tue, 03 Mar 2020 10:00:00 +0200

Make your code simpler with implicit casting in improved instanceof operator in Java 14.

The improvements in the instanceof operator (JEP 305 ) are not the most important feature of approaching Java 14. However, it finally implements the syntactic sugar that was available in Groovy for years, so I want to have my readers aware of it and simplify their code (once migrated to Java 14+ :-) ).

“instance of” usually is perceived as a scratch in well designed object oriented system. Nevertheless, there are places where it simplifies the code greatly and/or is the only sensible way to go.

The usual way

Double type checking in Java code is considered as something “normal” (or better something “common”):

if (o insteanceof String) {
    useString((String)o);
}

The same with combined condition checking:

if (o instanceof String && (((String)o).lenght > 10) {
    ...
}

It looks even worse if the class name is longer, e.g. ContentHandlerAlreadyRegisteredException (while received just Exception or Throwable).

The new way (Java 14+)

With fast approaching Java 14 (GA scheduler on 2020-03-17) it becomes much simpler:

if (o instanceof String s) {
    useString(s);
}

The new binding variable (of type String) is available in the if block.

It works also for combined condition checking:

if (o instanceof String s && s.length > 10) {
    ...
}

It can be used also in more complex if..elseif..else constructions. However, in those cases, the new switch..case syntax with the pattern matching allowing - still on the work desk - would be even more handy.

It is worth to remember that as a preview feature it has to explicitly enabled. See my other post how to do it in Idea, Gradle, Maven and command line.

The Groovy way

I wouldn’t be myself, if I skipped a comparison with Groovy :-). In Groovy that double type checking mitigation has been available for years. Even better, thanks to the AST transformation there is no need to define an extra variable. We can just use the original name which is visible with proper typing inside the block:

if (o instanceof String) {
    useString(o)
}

It is dead simple, but I have to admit that an extra binding variable with a custom name might be perceived as something slightly more readable with bigger block of code (which anyway could be usually moved to a separate method).

The switch..case statement is very powerful in Groovy. Checking the instance type is very straightforward:

switch(o) {
    case String:
        println "String"
        break
    case Integer:
        println "Integer"
        break
    default:
        throw new IllegalArgumentException(...)
}

However, even in Groovy 3, there is no type changing withing the scope (available in the if..else). As a result the following works without code completion with dynamic Groovy and fails with @CompileStatic:

void sortItOut(Object o) {

    switch(o) {
      case String:
        println "String: ${o.length()}" //only in dynamic Groovy
        break
      case Integer:
        println "Integer: ${o.longValue()}" //only in dynamic Groovy 
        break
      default:
        throw new IllegalArgumentException(o.toString())
    }
  }

I have to raise a ticket to support that ;-)

Update. It’s been already proposed - GROOVY-8411 .

Summary

There is a number of small, yet useful changes introduced in Java 12+ (or waiting for implementation in the incoming releases). Multiline string, yield in switch..case or smarter NullObjectExcpetion just to mention a few. Thanks to that Java becomes more and more compact (although Groovy or Kotlin are far ahead on that field).

Lead photo by Alicja, published in Pixabay, Pixabay License.

Enable Java 14 preview features in Gradle, Maven and Idea

Marcin Zajączkowski — Mon, 02 Mar 2020 09:00:00 +0200

Discover how to enable Java 14 preview features in Gradle, Maven, Idea and Command line.

Writing my next post about the improved instanceof operator in Java 14, I have noticed that enabling the preview features might be a good candidate for a short blog post to reference in other places.

Let’s start with the basics.

Command line

Standalone files with preview features of Java 14 can be easily run from the command line (especially as calling javac is no longer needed):

java --source 14 --enable-preview J14Instanceof.java

Idea

IntelliJ IDEA is known to support the new features and technologies in advance. With Java 14, it is available in Idea 2020.1, which the EAP (Early Access Program) version has been released in January 2020 .

It should be enough to just change the Java language settings in a given project to Java 14.

Maven

For Maven, just a few lines of XML should be required (I haven’t tested, I’m a Gradle guy ;-) :

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <release>14</release>
                <compilerArgs>--enable-preview</compilerArgs>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M3</version>
            <configuration>
                <argLine>--enable-preview</argLine>
            </configuration>
        </plugin>
    </plugins>
 </build>

Gradle

For Gradle, version 6.3 (currently available as SNAPSHOT only ) is required for run with Java 14. To cover multiple compile and test tasks in the project the following construction could be used:

sourceCompatibility = 14

tasks.withType(JavaCompile) {
    options.compilerArgs += '--enable-preview'
}
tasks.withType(Test) {
    jvmArgs += "--enable-preview"
}

Summary

Nothing fancy in this post, but I feel in my bones that I will use it as a reference more than once during my Migration to modern Java training :-).

Lead photo by StockSnap, published in Pixabay, Pixabay License.

new-feature on Solid Soft

Improved 'instanceof' operator in Java 14

The usual way

The new way (Java 14+)

The Groovy way

Summary

Enable Java 14 preview features in Gradle, Maven and Idea

Command line

Idea

Maven

Gradle

Summary