Java 14 introduces pattern matching of instanceof as a preview feature, allowing type variables to be declared and automatically converted while type checking; 2. Pattern matching is implemented through the if (obj instanceof Type variable) syntax, and variables are only valid in scope with the condition true and do not require casting; 3. This feature improves the readability and security of the code, reduces boilerplate code, and avoids the risk of ClassCastException; 4. When using it, you need to pay attention to variable scope and naming conflicts, and cannot mask existing external variables; 5. Since Java 16, instanceof pattern matching has become a formal standard function, which is widely applicable to scenarios such as equals method rewriting and polymorphic processing. It is recommended to replace traditional explicit type conversion.

Java 14 introduces Pattern Matching for instanceof , an important language improvement designed to simplify type checking and type conversion code. In traditional Java, we usually use instanceof like this:

 if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

Here you need to judge the type first, then perform casting, repetitive and redundant. Pattern matching makes this process simpler, safer and readable.

? What is instanceof pattern matching?

Starting from Java 14 (as a preview feature), instanceof supports directly declaring a type pattern variable . If the type matches, the variable will automatically complete the type conversion and act within if block.

grammar:

 if (obj instanceof Type variable) {
    // variable is already Type, no casting is required}

Example:

 if (obj instanceof String s) {
    System.out.println(s.length()); // s is the automatically converted String
} else {
    System.out.println("Not a String");
}

This line of code is equivalent to the previous explicit conversion, but is simpler and safer.

? Working mechanism of pattern matching

Pattern matching combines two operations:

1. Type check ( instanceof judgment)
2. Type conversion within scope

The compiler will ensure:

• The variable s is only available in scopes with the condition true
• Type conversion is safe and does not appear ClassCastException

 if (obj instanceof Integer i && i > 10) {
    System.out.println("Integer greater than 10: " i);
}

Note: You can use the new variable i directly in the condition, and even participate in subsequent logical judgments.

??Precautions for use

• Variable scope limitation : Schematic variables are only valid in scopes where instanceof is true .

   if (!(obj instanceof String s)) {
      // s is not available here!
      return;
  }
  System.out.println(s.length()); // ? Accessible

• Unable to mask external variables : The existing variable name cannot be used as a pattern variable.

   String s = "hello";
  if (obj instanceof String s) { } // ? Compilation error: variable duplication

• Support inheritance structure : It is often used to deal with polymorphic objects, such as extracting specific types from Object .

   Object obj = getSomeObject();
  
  if (obj instanceof Dog d) {
      d.bark();
  } else if (obj instanceof Cat c) {
      c.meow();
  }

? Practical application scenarios

1. Rewriting equals() method is simpler

Traditional writing:

 public boolean equals(Object o) {
    if (!(o instanceof Person)) return false;
    Person p = (Person) o;
    return name.equals(p.name);
}

After using pattern matching:

 public boolean equals(Object o) {
    return o instanceof Person p && name.equals(p.name);
}

Shorter, clearer, and avoids unnecessary brackets and conversions.

2. Handle mixed types in collections (not recommended, but sometimes unavoidable)

 for (Object item : mixedList) {
    if (item instanceof String s) {
        System.out.println("String: " s.toUpperCase());
    } else if (item instanceof Integer i) {
        System.out.println("Number: " (i * 2));
    }
}

? Evolution process (supported by Java version)

Starting from Java 16, instanceof pattern matching has become a standard feature and can be used without additional configuration.

? Summary: The benefits of pattern matching

• Reduce boilerplate code (boilerplate)
• Eliminate explicit casts to reduce the risk of errors
• Improve code readability and security
• More naturally support common patterns of "type query usage"

Basically that's it. Now write instanceof and don’t transform manually - use pattern matching to be more modern and elegant.

The above is the detailed content of Pattern Matching for `instanceof` in Modern Java. For more information, please follow other related articles on the PHP Chinese website!