Correspondance de modèles et enregistrements des modifications en Java que tout développeur Java doit connaître

Avec la sortie de Java 16, une amélioration majeure a été introduite avec l'introduction des enregistrements (JEP 395), qui ont permis une manière plus simple et plus concise de déclarer les classes principalement utilisées pour transporter des données. Cette amélioration a désormais été encore renforcée dans Java 21, avec l'ajout de Pattern Matching and Records (JEP 406). Cette nouvelle fonctionnalité permet d'utiliser la correspondance de modèles pour tester si une valeur est une instance d'une classe Record et extraire ses composants de manière plus rationalisée. Dans cet article, nous explorerons les changements apportés par la correspondance de modèles et les enregistrements dans Java 21 et comment cela peut profiter aux développeurs Java.

Les enregistrements comme supports transparents de données
Les enregistrements, introduits dans Java 16, sont des classes principalement utilisées pour stocker et transporter des données. Ce sont des supports transparents, ce qui signifie que leur objectif principal est de contenir des données, et toutes les autres fonctionnalités telles que les constructeurs, les méthodes et les méthodes equals/hashCode, sont générées automatiquement par le compilateur, sur la base des champs de données définis dans l'enregistrement. Cela les rend idéaux pour une utilisation dans des scénarios où les données doivent être sérialisées ou envoyées sur le réseau.

Prenons l'exemple d'une classe Line qui définit deux coordonnées X et Y :

enregistrer la ligne (int x, int y) {}

Pour utiliser cette classe, nous pouvons simplement créer une instance de la classe Line et accéder à ses champs de données à l'aide des méthodes d'accès aux composants intégrées, x() et y() :

Ligne ligne = nouvelle Ligne(0, 10);
int x = ligne.x();
int y = line.y();
System.out.println("X : " + x + ", Y : " + y); // Sortie : X : 0, Y : 10

Correspondance de modèles avec des enregistrements
Dans Java 21, Pattern Matching a été ajouté, ce qui permet de tester si une valeur est une instance d'une classe Record et d'extraire ses composants de manière plus rationalisée. Cette fonctionnalité est particulièrement utile lorsqu'il s'agit de bases de code volumineuses qui utilisent largement les enregistrements.

Considérons l'exemple suivant où nous voulons tester si un objet est une instance de la classe Line et extraire ses composants :

longueur du vide statique (Obj objet) {
if (obj instanceof Line l) {
int x = l.x();
int y = l.y();
System.out.println(y-x);
>
>
Comme vous pouvez le voir, nous avons utilisé un modèle de type pour tester si l'objet est une instance de Point et si tel est le cas, nous avons extrait ses composants en appelant les méthodes d'accès aux composants intégrées. Bien que ce code fonctionne, il peut être encore simplifié grâce à l'utilisation d'un modèle d'enregistrement dans Java 21.

Avec le modèle d'enregistrement, nous pouvons non seulement tester si une valeur est une instance d'une classe Record, mais nous pouvons également extraire ses composants dans une seule ligne de code. Ceci est réalisé en effectuant la déclaration des variables locales pour les composants extraits dans le modèle lui-même et en initialisant ces variables en appelant les méthodes d'accès lorsque la valeur correspond au modèle.

Considérez le code suivant qui utilise un modèle d'enregistrement :

longueur du vide statique (Obj objet) {
if (obj instanceof Line(int x, int y)) {
System.out.println(y-x);
>
>
Ce code est beaucoup plus concis et lisible. Nous avons éliminé le besoin de créer un nouvel objet et d'invoquer ses méthodes d'accès aux composants pour obtenir les données. Le modèle d'enregistrement extrait et initialise directement les composants pour nous, ce qui rend notre code plus rationalisé.

Modèles d'enregistrement imbriqués
L'un des défis majeurs auxquels sont confrontés les développeurs consiste à gérer des graphiques d'objets complexes et à en extraire des données. C'est là qu'intervient le véritable pouvoir de la correspondance de modèles, car elle nous permet d'évoluer avec élégance et de faire correspondre des graphiques d'objets plus complexes.

Considérez les classes suivantes : Employé, Département (énumération) et Entreprise (enregistrement). Nous pouvons utiliser un modèle d'enregistrement pour extraire le service d'un employé d'un objet Société :

// Depuis Java 21
static void printEmployeeDepartment (Société c, Nom de la chaîne) {
if (c instanceof Company (Département, Liste employés)) {
pour (Employé e : employés) {
if (e.getName().equals(name)) {
System.out.println(nom + " est dans " + département + " département. ");
revenir ;
>
>
>
System.out.println(nom + " introuvable. ");
>
Dans cet exemple, nous utilisons des modèles imbriqués pour extraire le service d'un employé d'un objet Société. Nous vérifions si l'objet Company donné a un département et une liste d'employés, puis parcourons la liste pour trouver l'employé portant le nom donné. Si l'employé est retrouvé, nous imprimons son département. Sinon, nous imprimons un message indiquant que l'employé n'a pas été trouvé.

Les modèles imbriqués peuvent également être utilisés dans des situations où nous souhaitons faire correspondre et déconstruire plusieurs valeurs à la fois. Considérons l'exemple suivant où nous voulons vérifier si une coordonnée donnée est située à l'intérieur d'un rectangle :

//À partir de Java 21
enregistrer le point (double x, double y) {}

enregistrer le rectangle (point supérieur gauche, point inférieur droit) {}

// vérifie si le point donné est situé à l'intérieur du rectangle donné
booléen statique isPointInsideRectangle(Point p, Rectangle r) {
if (r instanceof Rectangle(Point(var x1, var y1), Point(var x2, var y2))) {
if (p.x() > x1 && p.y() > y1 && p.x() < x2 && p.y() < y2) {
renvoie vrai ;
>
>
retourner faux ;
>

Dans cet exemple, nous utilisons des modèles imbriqués pour vérifier si un objet Point donné se situe dans les limites d'un objet Rectangle donné. Le motif imbriqué nous permet d'accéder aux coordonnées x et y des points supérieur gauche et inférieur droit du rectangle sans avoir à écrire plusieurs lignes de code.

En conclusion, avec l'ajout de Pattern Matching and Records (JEP 406) dans Java 21, il y a une amélioration significative dans la façon dont nous pouvons gérer et extraire des données à partir d'objets complexes. Cette fonctionnalité simplifie grandement le code et le rend plus lisible et concis. Cela aide également à gérer les scénarios d’échec dans lesquels la correspondance de modèle pourrait échouer. Avec ces changements, Java 21 continue de rationaliser le code et d'améliorer l'expérience de développement pour les développeurs Java.

Améliorez vos compétences Java 21 avec les tests de pratique professionnelle pour développeurs Java SE 21 de MyExamCloud. Développez et testez vos connaissances pour devenir un expert Java 21.

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!