Enhanced JEP 394: Pattern Matching for instanceof

JEP 394: Pattern Matching for instanceof is a significant feature introduced in Java 16 and enhanced in Java 17. The goal of this enhancement is to simplify and improve the use of instanceof for type-checking and casting. Traditionally, the instanceof operator required a two-step process: first, checking if an object is an instance of a particular class, and then manually casting it to that class. JEP 394 introduces a more compact and safe way to handle this, reducing boilerplate code and improving readability.

The Traditional Approach

Before Java 16, the use of instanceof was verbose. A typical usage pattern required two separate steps:

Check if the object is of a specific type using instanceof.
Cast the object to that type after the check.

For example, to check if an object is an instance of String and then use it, you would write:

if (obj instanceof String) {
    String str = (String) obj;  // Explicit cast
    System.out.println(str.length());
}Code language: JavaScript (javascript)

This code is repetitive and prone to mistakes, particularly with more complex type checks and casts.

The Pattern Matching Enhancement

With JEP 394, pattern matching introduces a more concise and safer way to perform the type check and cast in a single step. Now, you can both check the type of an object and directly bind it to a variable of that type in one statement.

The new syntax introduced is:

if (obj instanceof String str) {
    System.out.println(str.length());
}Code language: JavaScript (javascript)

Here, obj instanceof String str checks if obj is an instance of String and, if true, directly binds it to the variable str, no need for explicit casting.

This enhancement provides several benefits, including:

Reduced Boilerplate: You no longer need to write repetitive casting code.
Improved Readability: The type-checking and casting logic is more compact and easier to follow.
Type Safety: It avoids ClassCastException by ensuring that the type check and cast happen together.

How Pattern Matching Works

In this new pattern matching syntax, the object is checked for its type in the condition. If the type matches, the object is automatically cast to the specified type and made available as a local variable inside the block.

For example:

Object obj = "Hello, World!";

if (obj instanceof String str) {
    System.out.println(str.length());  // Directly use 'str', no casting needed
}Code language: JavaScript (javascript)

In the above example:

The condition obj instanceof String str first checks if obj is an instance of String.
If it is, obj is cast to String automatically and assigned to the variable str, which can be used directly without any explicit cast.

This eliminates the need for manual casting and makes the code cleaner.

Benefits of Pattern Matching for `instanceof`

Reduced Boilerplate Code: The old instanceof approach required you to explicitly cast the object after checking it, leading to repetitive code. Pattern matching eliminates this.
Improved Readability: The syntax is clearer and less verbose, which makes the code easier to understand.
Type Safety: With pattern matching, the compiler ensures that the type check and cast happen together, eliminating the possibility of a ClassCastException.
Cleaner and Safer Code: This feature encourages a more declarative way of working with objects, making it less error-prone and more expressive.

Example Code: Before and After

Before Java 16 (Without Pattern Matching):

public void printLength(Object obj) {
    if (obj instanceof String) {
        String str = (String) obj;  // Manual cast
        System.out.println(str.length());
    }
}Code language: JavaScript (javascript)

After Java 16+ (With Pattern Matching):

public void printLength(Object obj) {
    if (obj instanceof String str) {  // Automatic casting and binding
        System.out.println(str.length());
    }
}Code language: JavaScript (javascript)

The difference is clear: the pattern matching version is more concise, easier to read, and eliminates the explicit cast.

Pattern Matching with Other Types

This enhancement works with any class or interface type. The pattern matching syntax is not limited to String but applies to any type check and cast.

For example:

Object obj = new ArrayList<>();

if (obj instanceof ArrayList<?> list) {
    System.out.println("List size: " + list.size());
}Code language: PHP (php)

In this case, obj is checked to see if it’s an instance of ArrayList, and if so, it’s automatically cast to ArrayList<?> and assigned to the variable list.

JEP 394 introduces pattern matching for instanceof in Java 16 and enhances it in Java 17, providing a simpler, safer, and more readable way to check types and cast objects in one operation. This new feature reduces boilerplate code, improves code clarity, and prevents common errors related to type casting.

As Java continues to evolve, pattern matching for instanceof is a significant step toward making the language more expressive and reducing boilerplate, enhancing both developer productivity and code quality.