How to use Pattern Matching for type rewriting and type assertion in Java 14

Introduction:
Java is a statically typed language, and type checking is one of its most important features. In previous Java versions, type checking was mainly implemented by using the instanceof keyword and forced type conversion. However, the new feature of Pattern Matching was introduced in Java 14, making type rewriting and type assertion more concise and intuitive. This article will introduce how to use Pattern Matching for type rewriting and type assertion in Java 14, and provide relevant code examples.

1. Type Overriding

Type overriding means that when using type conversion, the target type can be specified directly in the conversion statement without the need for forced type conversion. This was not allowed in previous Java versions, and type conversion must be achieved through cast. In Java 14, Pattern Matching can be used to achieve more concise type rewriting.

The following is a sample code that demonstrates how to use Pattern Matching for type rewriting in Java 14:

public class TypeOverrideExample {
    public static void main(String[] args) {
        CharSequence sequence = "Hello Java 14!";
        if (sequence instanceof String s) {
            // 使用s作為String類型的變量
            System.out.println(s.toLowerCase());
        }
    }
}

In the above code, we define a variable sequence of type CharSequence, and assign it as a string. Then, use the if statement and the instanceof keyword to determine whether the sequence is of type String. If so, then you can use type rewriting in the if statement to directly specify the variable s as a String type, and you can directly use s as a String type variable in the if statement. This eliminates the previous step of forced type conversion.

2. Type Assertion

Type assertion means that when using type checking, you can directly assign the type check result of a variable to a new variable without using the instanceof key again. Words are type checked. In Java 14, you can use Pattern Matching to achieve more concise type assertions.

The following is a sample code that demonstrates how to use Pattern Matching for type assertion in Java 14:

public class TypeAssertionExample {
    public static void main(String[] args) {
        Object object = "Hello Java 14!";
        if (object instanceof String s) {
            // 使用s作為String類型的變量
            System.out.println(s.toLowerCase());
        } else {
            System.out.println("object is not a String");
        }
    }
}

In the above code, we define a variable object of type Object, and Assign it to a string. Then, use the if statement and instanceof keyword to determine whether the object is of type String. If so, then you can use a type assertion in the if statement to directly specify the variable s as a String type, and you can directly use s as a String type variable in the if statement. If not, we can handle it accordingly in the else statement.

Conclusion:

This article introduces the use of Pattern Matching for type rewriting and type assertion in Java 14, and provides relevant code examples. Through Pattern Matching, we can perform type conversion and checking more concisely and intuitively, avoiding cumbersome forced type conversion and the use of redundant instanceof keywords. I hope readers can learn about this new feature through this article and apply it to their own code in actual development.

The above is the detailed content of How to use Pattern Matching for type rewriting and type assertion in Java 14. For more information, please follow other related articles on the PHP Chinese website!