Comment utiliser la correspondance de modèles pour la conversion et l'extraction de type dans Java 14

Comment utiliser la correspondance de modèles pour la conversion et l'extraction de types dans Java 14

Une fonctionnalité très puissante est introduite dans Java 14 - la correspondance de modèles. Cette fonctionnalité rend le jugement de type plus concis et plus pratique, en particulier lors de la réalisation de conversions et d'extractions de type. Cet article explique comment utiliser la correspondance de modèles pour effectuer la conversion et l'extraction de type dans Java 14, et l'illustre à travers des exemples de code.

Dans les versions précédentes de Java, nous devions généralement passer par deux étapes pour effectuer la conversion et l'extraction de type. Tout d’abord, nous devons vérifier le type de l’objet à l’aide du mot-clé instanceof, puis le convertir en type cible à l’aide de cast. Cette approche est très fastidieuse et sujette aux erreurs, en particulier lorsqu'il s'agit de relations d'objets complexes.

La correspondance de modèles dans Java 14 simplifie le processus de détermination du type en introduisant une nouvelle syntaxe d'instance et une correspondance de modèles dans les instructions switch. Regardons quelques exemples pour comprendre comment les utiliser.

Tout d’abord, considérons un exemple simple. Supposons que nous ayons une classe abstraite Shape, qui contient une méthode appelée zone, et que nous devions calculer la zone en fonction de différentes formes. Nous pouvons définir plusieurs classes de formes spécifiques, telles que Cercle, Rectangle et 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;
    }
}

Dans les versions précédentes de Java, nous devions souvent utiliser instanceof pour vérifier le type de forme spécifique et effectuer une conversion de type cast :

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();
    // 其他处理...
}

Dans Java 14, nous pouvons utiliser la nouvelle syntaxe instanceof pour une écriture de code plus concise :

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();
    // 其他处理...
}

Dans Avec cette nouvelle syntaxe, nous déplaçons le code de conversion vers la droite de instanceof, et les variables locales circle, rectangle et triangle peuvent être utilisées directement dans le code suivant. L’avantage est que nous n’avons pas besoin de déclarer explicitement ces variables locales, ce qui améliore la simplicité et la lisibilité du code.

En plus du jugement de type dans les instructions conditionnelles, Pattern Matching peut également être utilisé dans les instructions switch. Dans les versions Java précédentes, nous ne pouvions utiliser des constantes pour la correspondance que dans le cas de l'instruction switch. Dans Java 14, nous pouvons utiliser des modèles de type pour la correspondance. Regardons un exemple :

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();
        // 其他处理...
    }
}

Dans cette nouvelle instruction switch, nous pouvons faire correspondre selon le type de forme et utiliser les variables locales cercle, rectangle et triangle directement dans le code suivant. De cette façon, nous n'avons pas besoin d'effectuer à plusieurs reprises une vérification de type et une conversion de type forcée, ce qui simplifie grandement l'écriture et la maintenance du code.

Pour résumer, l'utilisation de Pattern Matching pour la conversion et l'extraction de type dans Java 14 peut grandement simplifier notre code et améliorer la lisibilité et la maintenabilité du code. En introduisant la nouvelle syntaxe instanceof et la correspondance de modèles dans les instructions switch, nous pouvons éliminer le code redondant et éviter les erreurs de conversion de type.

Cependant, il est important de noter que le Pattern Matching ne peut être utilisé qu'en Java 14 et supérieur. Dans les anciennes versions de Java, nous devons toujours utiliser des méthodes traditionnelles pour la détermination du type et la coercition. Par conséquent, lorsque vous utilisez Pattern Matching, il est important de vous assurer que votre code s'exécute sur la bonne version de Java.

J'espère que cet article vous aidera à comprendre et à utiliser la correspondance de modèles dans Java 14. Écrire du code clair et concis est la tâche de tout programmeur, et la correspondance de modèles est une étape importante pour que le langage Java progresse vers cet objectif.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!