Java 16 introduced a new feature called “Pattern Matching for instanceof” which simplifies the process of casting objects in Java. This feature improves the readability and safety of code that uses instanceof and casting by allowing developers to combine the two operations into a single step.

In this blog article, we will explore what Pattern Matching for instanceof is, how it works, and how to use it in your Java applications.

What is Pattern Matching for instanceof?

Pattern Matching for instanceof is a new feature in Java 16 that improves the syntax and safety of casting in Java. It allows developers to combine the operations of instanceof and casting into a single step, making code more concise and readable.

The feature achieves this by introducing a new syntax that allows us to declare a variable as part of an instanceof check. This variable can then be used in the code block that follows the check, eliminating the need for an additional cast.

How Pattern Matching for instanceof Works

Pattern Matching for instanceof works by allowing us to declare a variable as part of an instanceof check. The syntax for this is as follows:

if (object instanceof ClassName variableName) {     
	// Use variableName as a variable of type ClassName in this block 
}

In this syntax, object is the object that we are checking, ClassName is the class that we are checking against, and variableName is the name of the variable that we want to create if the check passes.

If the instanceof check passes, the variable variableName is created and can be used in the code block that follows. This variable has a type of ClassName, so there is no need to cast it.

Example Usage

Let’s take a look at an example to see how Pattern Matching for instanceof works in practice. Suppose we have an interface called Shape and two classes that implement it: Circle and Rectangle. We want to write a method that returns the area of a shape, but we don’t know which type of shape we are dealing with.

We can use Pattern Matching for instanceof to simplify this method as follows:

public double getArea(Shape shape) {
	if (shape instanceof Circle circle) {
	         return Math.PI * circle.getRadius() * circle.getRadius();     
	} else if (shape instanceof Rectangle rectangle) {
	         return rectangle.getWidth() * rectangle.getHeight();     
	} else {
	          throw new IllegalArgumentException("Unknown shape type");     
	} 
}

In this example, we use Pattern Matching for instanceof to check if the shape parameter is an instance of Circle or Rectangle. If it is, we create a variable (circle or rectangle) of the appropriate type, which can be used in the code block that follows.

We can then use these variables to calculate the area of the shape. If the shape is neither a circle nor a rectangle, we throw an exception with an error message.

Conclusion

Pattern Matching for instanceof is a new feature in Java 16 that simplifies the process of casting in Java. By allowing us to combine the operations of instanceof and casting into a single step, it makes code more concise and readable. The feature is especially useful in situations where we need to deal with multiple types of objects, such as when working with interfaces or abstract classes. With Pattern Matching for instanceof, we can improve the safety and readability of our code, making it easier to understand and maintain.