Enhanced instanceof pattern matching, introduced in Java 16 (as a preview feature) and finalized in Java 17, allows you to combine type checking with type casting, reducing boilerplate code and making it more concise and readable.

Here’s how you can use enhanced instanceof pattern matching:

1. Basic Usage:
   Instead of separately checking if an object is an instance of a class and then casting it, you can do both in one step using the pattern matching feature. The syntax is:

   if (obj instanceof Type variableName) {
      // variableName is automatically cast to Type
   }
   

   Example:

   Object obj = "Hello, Java!";
   
   if (obj instanceof String str) { // This checks and casts obj to String
      System.out.println("String length: " + str.length());
   } else {
      System.out.println("Not a string.");
   }
   

   This eliminates the need for explicit type casting.

2. Combine with Logical Operators:
   You can combine the pattern matching with additional conditions using logical operators like && or ||.

   Example:

   Object obj = "Patterns in Java";
   
   if (obj instanceof String str && str.length() > 10) {
      System.out.println("String is longer than 10 characters: " + str);
   } else {
      System.out.println("String is too short or not a string at all.");
   }
   

   In this case, the str variable is only in scope if both conditions are true.

3. Scope of the Pattern Variable:

   • The pattern variable (e.g., str in the examples above) is only accessible within the block where the pattern matching is true.
   • Outside of the if block, the variable doesn’t exist.
4. Negating with !instanceof:
   Pattern matching itself cannot be negated directly (no “not instanceof”), but you can invert the condition like this:

   if (!(obj instanceof String)) {
      System.out.println("Not a string.");
   }
   

5. Using Pattern Matching in switch:
   Starting from Java 17 (as a preview) and improved in later versions, you can use pattern matching in switch statements for more powerful expressions. For example:

   Object obj = "Java 17";
   
   switch (obj) {
      case String str && str.length() > 5 -> System.out.println("Long string: " + str);
      case String str -> System.out.println("Short string: " + str);
      default -> System.out.println("Not a string.");
   }
   

   This allows a combination of pattern matching and conditionals directly within switch.

Benefits of Enhanced instanceof Pattern Matching

• Reduction of Boilerplate Code: By avoiding explicit casting and declaring new variables.
• Improved Readability: Simplifies conditional checks by combining the instance check and cast in one step.
• Type Safety: Provides better compile-time safety for the variables you use after a cast.

Recap of the Code Features

From the files you’ve referenced:

1. PatternMatchingExample.java demonstrates simple pattern matching with instanceof, where the type check and assignment are done in one step.
2. PatternMatchingExampleCombine.java shows combining pattern matching with additional conditions (e.g., &&).

Both examples illustrate the practical and concise approach to type checking and casting introduced via enhanced instanceof pattern matching.

Pattern matching with the instanceof operator was introduced in Java 16 (as a preview feature) and became a standard feature in Java 17. It simplifies the process of type casting when checking an object’s type, making the code shorter and more readable.

Here’s how you can use pattern matching with instanceof in Java 17:

Syntax

With pattern matching, you can directly declare a local variable while checking the type with instanceof. If the condition is true, the variable is automatically cast to the specified type, and you can use it without explicit casting.

if (object instanceof Type variableName) {
   // Use variableName, which is already cast to Type
}

Key Features:

1. Type Checking and Casting in One Step: No need for an explicit cast.
2. Shorter Code: Reduces boilerplate.
3. Available Within Scope: The variable is accessible only within the scope of the if block where the condition is evaluated as true.
4. Guarded Pattern (Available in Java 20+ – Preview): Introduced later, allowing additional conditions within instanceof.

Example 1: Basic Usage

package org.kodejava.basic;

public class PatternMatchingExample {
   public static void main(String[] args) {
      Object obj = "Hello, Java 17!";

      if (obj instanceof String str) {
         // Type already checked and cast to `String`
         System.out.println("String length: " + str.length());
      } else {
         System.out.println("Not a string.");
      }
   }
}

Explanation:

• The variable str is declared and automatically cast to String in the same instanceof statement.
• Within the if block, you can directly use str as it is guaranteed to be a String.

Example 2: Pattern Matching in Loops

package org.kodejava.basic;

import java.util.List;

public class PatternMatchingExample {
   public static void main(String[] args) {
      List<Object> objects = List.of("Java", 42, 3.14, "Pattern Matching");

      for (Object obj : objects) {
         if (obj instanceof String str) {
            System.out.println("Found a String: " + str.toUpperCase());
         } else if (obj instanceof Integer num) {
            System.out.println("Found an Integer: " + (num * 2));
         } else if (obj instanceof Double decimal) {
            System.out.println("Found a Double: " + (decimal + 1));
         } else {
            System.out.println("Unknown type: " + obj);
         }
      }
   }
}

Output:

Found a String: JAVA
Found an Integer: 84
Found a Double: 4.14
Found a String: PATTERN MATCHING

Example 3: Combining && Conditions

You can combine pattern matching with additional conditions:

package org.kodejava.basic;

public class PatternMatchingExample {
   public static void main(String[] args) {
      Object obj = "Hello";

      if (obj instanceof String str && str.length() > 5) {
         System.out.println("String is longer than 5 characters: " + str);
      } else {
         System.out.println("Not a long string (or not a string at all).");
      }
   }
}

Notes:

1. Scope of Variable:
   The variable introduced inside the instanceof is only accessible inside the block where the condition is true. For example:

   if (obj instanceof String str) {
      System.out.println(str); // str is available here
   }
   // System.out.println(str); // ERROR: str not available here
   

2. Null Safety:
   If the object being matched is null, the instanceof check will return false, so you don’t have to handle nulls manually.

Benefits:

• Simplifies code structure.
• Eliminates the need for verbose casting.
• Improves readability and reduces errors associated with unnecessary manual typecasting.

Pattern matching with instanceof is now widely used in modern Java. Make sure you’re using JDK 17 or later to take advantage of this feature!