Les modèles d'enregistrement Java ont été introduits dans Java 16 dans le cadre du projet Amber et sont améliorés dans Java 21 avec l'ajout de déconstructeurs et de correspondance de modèles. Cette fonctionnalité permet une manière plus concise et flexible de gérer les données dans les applications Java. Dans ce didacticiel, nous aborderons le concept de modèles d'enregistrement, la manière dont ils contribuent à la correspondance de modèles et divers exemples de codage.

1. Récapitulatif rapide des enregistrements Java
Avant de plonger dans les modèles d'enregistrement, faisons un bref récapitulatif des enregistrements Java. Les enregistrements ont été introduits dans Java 14 en tant que nouveau type de classe spécialement conçu pour contenir des données immuables. Ils éliminent le besoin d’écrire du code passe-partout en fournissant une syntaxe plus concise pour définir des classes avec des données. Dans l'exemple suivant, nous définissons un enregistrement nommé « Personne » avec trois champs : prénom, nom et âge.

enregistrer la personne (String firstName, String lastName, int age) {}

Les enregistrements, étant immuables, restreignent certaines caractéristiques :

• Tous les champs sont définitifs
• La classe est implicitement finale
• La déclaration des champs d'instance est interdite

Les enregistrements génèrent automatiquement un constructeur et des méthodes getter pour chaque champ, ce qui les rend plus adaptés aux supports de données que les classes traditionnelles.

2. Que sont les modèles d'enregistrement ?
Les modèles d'enregistrement, introduits dans Java 21, combinent le concept de modèles avec des enregistrements qui permettent de déconstruire et d'extraire facilement les valeurs des enregistrements. Un modèle d'enregistrement se compose d'un type de classe d'enregistrement et de variables de modèle facultatives auxquelles sont attribuées des valeurs extraites de l'enregistrement cible uniquement si le test est réussi.

La valeur nulle ne correspond à aucun modèle d'enregistrement, les variables de modèle ne seront donc pas initialisées dans ce cas.

3. Destructeurs d'enregistrements
Un destructeur est l'inverse d'un constructeur. Il extrait les valeurs d'un objet au lieu de les ajouter. Dans le contexte des enregistrements, un destructeur est appelé « déconstructeur ». Il permet de décomposer les valeurs d'enregistrement en leurs composants individuels. Supposons que nous ayons un enregistrement nommé « Nom » avec les champs suivants :

enregistrer le client (String firstName, String lastName, int age) {}

Nous pouvons utiliser un déconstructeur pour extraire les valeurs de ces champs d'une instance de l'enregistrement « Client », comme le montre l'exemple suivant :

Client client = nouveau client("Jane", "Smith", 30);

if (instance client du client (String firstName, String lastName, int age)) {
System.out.println("Prénom : " firstName); // Jeanne
System.out.println("Nom : " lastName); // Forgeron
System.out.println("Âge : " âge); // 30
}

Les structures d'enregistrement peuvent être utiles dans les situations où nous devons stocker et récupérer plusieurs valeurs liées en tant qu'objet unique. La fonction de déconstruction des enregistrements nous permet d'extraire et d'utiliser facilement ces valeurs dans notre code.

4. Modèles d'enregistrement dans les instructions Switch
Java 16 a introduit la correspondance de modèles pour les instructions instanceof, qui a été étendue dans Java 21 pour inclure les instructions switch. Il permet un code plus concis et lisible tout en gérant plusieurs modèles.

Disons que nous avons un enregistrement nommé "Account" avec trois sous-types : "SavingAccount", "CreditCardAccount" et "HomeLoanAccount". Chaque sous-type a une manière différente de calculer son solde. Nous pouvons utiliser le modèle d'enregistrement dans une instruction switch pour gérer ces trois cas, comme indiqué ci-dessous :

interface Compte {}
record SavingAccount (double solde) implémente le compte {}
record CreditCardAccount (double creditLimit, double utilisé) implémente le compte {}
record HomeLoanAccount (double totalAmount, double montantPaid) implémente le compte {}

Compte de compte= nouveau compte de carte de crédit (10 000, 1 000);

interrupteur (forme) {
cas SavingAccount s :
System.out.println("Le solde du compte est " le solde);
casser;
cas CreditCardAccount c:
System.out.println("Le solde de crédit est : " (creditLimit-used));
casser;
cas HomeLoanAccount h :
System.out.println("Solde " (totalAmount-amountPaid));
casser;
défaut:
System.out.println("Compte inconnu");
}

5. Motifs imbriqués
En plus d'extraire les valeurs d'un seul enregistrement, les modèles d'enregistrement peuvent également être imbriqués pour gérer des enregistrements plus complexes. Supposons que nous ayons un enregistrement nommé « Compte » comportant un champ de type « Client » et un autre champ de type « Adresse ». Nous pouvons utiliser des modèles d'enregistrement imbriqués pour extraire les valeurs de ces deux champs, comme le montre l'exemple suivant :

enregistrer le client (String firstName, String lastName, int age) {}

enregistrer le compte (client client, adresse adresse) {}

Client client = nouveau Client("John", "Doe", 25);
Adresse adresse = nouvelle adresse("123 Main St.","Ville", "État");
Compte compte = nouveau compte (client, adresse);

if (instance de compte de compte (client (fnom, lnom, âge), adresse (rue, ville, état))) {
System.out.println("Prénom : " fName); // John
System.out.println("Nom : " lName); // Biche
System.out.println("Âge : " âge); // 25
System.out.println("Adresse : " rue ", " ville ", " état ); // 123 Main St., Ville, État
}

Dans cet exemple, nous utilisons deux modèles imbriqués pour extraire les valeurs des champs « Client » et « Adresse » de l'enregistrement « Compte ».

6. Correspondance des composants
Les modèles d'enregistrement permettent plus de flexibilité car les variables de modèle ne doivent pas nécessairement correspondre aux noms de composants d'un enregistrement. Tant qu'ils sont compatibles, la correspondance de modèles sera réussie. Par exemple:

enregistrer le client (String firstName, String lastName, int age) {}

enregistrer le compte (client client, adresse adresse) {}

Client client = nouveau Client("John", "Doe", 25);

if (instance client du client (var fn, var ln, var age)) {
System.out.println("Prénom : " fn); // John
System.out.println("Nom : " ln); // Biche
System.out.println("Âge : " âge); // 25
}

// Accès aux composants d'enregistrement imbriqués
Compte compte = nouveau compte(client, nouvelle adresse("123 Main St", "New York", "NY"));
if (instance de compte de compte (var client, var adresse)) {
System.out.println("Client : " client); // Client[firstName=John, lastName=Doe, age=25]
System.out.println("Adresse : " adresse); // Adresse[street=123 Main St, city=New York, state=NY]
}

Ici, les variables de modèle « fn » et « ln » sont différentes des noms de composants correspondants de « fName » et « lName » dans l'enregistrement « Customer ». Cela rend les modèles d'enregistrement plus flexibles et évite tout conflit potentiel avec les noms de variables.

7. Conclusion
En conclusion, les modèles d'enregistrement Java constituent un moyen pratique de déconstruire les enregistrements et d'en extraire des valeurs. Ils rendent le code plus concis, propre et lisible tout en gérant la correspondance de modèles dans les instructions instanceof et switch. Les modèles d'enregistrement, combinés aux destructeurs d'enregistrements, permettent une gestion plus robuste des enregistrements complexes. Dans l'ensemble, cette fonctionnalité améliore l'utilisation des enregistrements comme supports de données et rend la programmation Java plus agréable.

Les développeurs peuvent découvrir davantage de fonctionnalités Java 21 en étudiant pour l'examen SE 21 Developer Certified Professional à l'aide des tests pratiques 1Z0-830 de MyExamCloud.