How to use Pattern Matching for type casting and extraction in Java 14

How to use Pattern Matching for type casting and extraction in Java 14

A very powerful feature is introduced in Java 14 - Pattern Matching. This feature makes type judgment more concise and convenient, especially when performing casts and type extractions. This article will introduce how to use Pattern Matching to perform type casting and extraction in Java 14, and illustrate it through code examples.

In previous Java versions, we usually needed to go through two steps to perform type casting and extraction. First, we need to check the type of the object using the instanceof keyword and then convert it to the target type using cast. This approach is very tedious and error-prone, especially when dealing with complex object relationships.

Pattern Matching in Java 14 simplifies the process of type determination by introducing new instanceof syntax and pattern matching in switch statements. Let's look at some examples to understand how to use them.

First, let's consider a simple example. Suppose we have an abstract class Shape, which contains a method called area, and we need to calculate the area based on different shapes. We can define several specific shape classes, such as Circle, Rectangle and Triangle.

abstract class Shape {
    abstract double area();
}

class Circle extends Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double width;
    double height;

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    double area() {
        return width * height;
    }
}

class Triangle extends Shape {
    double base;
    double height;

    Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }

    double area() {
        return 0.5 * base * height;
    }
}

In previous Java versions, we often needed to use instanceof to check the specific shape type and perform cast type conversion:

Shape shape = ...; // 初始化一个形状对象

if (shape instanceof Circle) {
    Circle circle = (Circle) shape; // 强制类型转换
    double area = circle.area();
    // 其他处理...
} else if (shape instanceof Rectangle) {
    Rectangle rectangle = (Rectangle) shape;
    double area = rectangle.area();
    // 其他处理...
} else if (shape instanceof Triangle) {
    Triangle triangle = (Triangle) shape;
    double area = triangle.area();
    // 其他处理...
}

In Java 14, we can use the new instanceof syntax for more concise code writing:

Shape shape = ...; // 初始化一个形状对象

if (shape instanceof Circle circle) {
    double area = circle.area();
    // 其他处理...
} else if (shape instanceof Rectangle rectangle) {
    double area = rectangle.area();
    // 其他处理...
} else if (shape instanceof Triangle triangle) {
    double area = triangle.area();
    // 其他处理...
}

In this new syntax, we have moved the cast code to the right side of instanceof, and can use local variables circle and rectangle directly in subsequent code and triangle. The advantage of this is that we do not need to explicitly declare these local variables, which improves the simplicity and readability of the code.

In addition to type judgment in conditional statements, Pattern Matching can also be used in switch statements. In previous Java versions, we could only use constants for matching in the case of the switch statement. In Java 14, we can use type patterns for matching. Let's look at an example:

Shape shape = ...; // 初始化一个形状对象

switch (shape) {
    case Circle circle -> {
        double area = circle.area();
        // 其他处理...
    }
    case Rectangle rectangle -> {
        double area = rectangle.area();
        // 其他处理...
    }
    case Triangle triangle -> {
        double area = triangle.area();
        // 其他处理...
    }
}

In this new switch statement, we can match according to the type of shape, and use the local variables circle, rectangle, and triangle directly in subsequent code. In this way, we do not need to repeatedly perform type checking and forced type conversion, which greatly simplifies code writing and maintenance.

To summarize, using Pattern Matching for type casting and extraction in Java 14 can greatly simplify our code and improve the readability and maintainability of the code. By introducing the new instanceof syntax and pattern matching in switch statements, we can eliminate redundant code and avoid type conversion errors.

However, it should be noted that Pattern Matching can only be used in Java 14 and above. In older versions of Java, we still need to use traditional methods for type determination and coercion. Therefore, when using Pattern Matching, it is important to ensure that your code is running on the correct Java version.

I hope this article will help you understand and use Pattern Matching in Java 14. Writing clear and concise code is what every programmer pursues, and Pattern Matching is a big step for the Java language to move toward this goal.

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