Records et Pattern Matching Pour Instanceof Finalisés Dans JDK 16

Les versions finales des records et le nouveau pattern matching pour instanceof sont prévues pour JDK 16. Avec ces nouvelles fonctionnalités, le code boilerplate peut être réduit et le code devient moins sujet aux erreurs.

Les deux fonctionnalités étaient déjà disponibles en preview dans le JDK 14 et 15. Elles sont légèrement améliorées et devraient être disponibles dans le JDK 16 dont la sortie est prévue pour mars 2021. Si tout se passe comme prévu, alors les nouvelles fonctionnalités seront disponibles dans le JDK 17, la prochaine version LTS, attendue en septembre 2021.

Les records sont la version Java des tuples nommés - essentiellement des conteneurs pour une séquence ordonnée d'éléments. Lors de l'utilisation de records, il n'est plus possible de découpler l'API et la représentation - les deux sont dérivés de la déclaration du record.

L'un des principaux effets de cette fonctionnalité est qu'elle réduit le code boilerplate. Jusqu'à présent, les classes avec des constructeurs et des méthodes telles que les getters, les setters, equals, toString et hashCode devaient être écrites à la main. Certains projets utilisaient des bibliothèques telles que Lombok pour réduire la quantité de code boilerplate. Malheureusement, Lombok a besoin d'un support supplémentaire sous la forme de plugins d'IDE. La nouvelle fonctionnalité records devrait rendre ce processus plus facile et moins sujet aux erreurs.

Pour commencer, un record doit être défini :

record Name(String firstName, String lastName){}

Les records peuvent être déclarés dans un fichier séparé ou dans une autre classe. Il existe de nombreux cas d'utilisation des records; ils peuvent être utilisés pour renvoyer plusieurs valeurs d'une méthode, sous forme de clés composées dans une map ou simplement en tant qu'objets de données.

Lorsqu'une classe normale est définie, un constructeur par défaut est implicitement ajouté. Les recordss ont un comportement similaire et contiennent implicitement un certain nombre de membres :

• champs privés pour tous les composants du record
• méthodes d'accès public pour tous les composants du record
• constructeur avec des arguments pour tous les composants du record. Ce constructeur s'appelle le constructeur canonique
• les méthodes equals, toString et hashCode avec leur implémentation

Le record défini précédemment ne contient aucun code personnalisé, mais il est possible de définir des méthodes explicites. Il est même possible de déclarer explicitement les différentes méthodes ajoutées implicitement et le constructeur canonique. Par exemple, il est possible de créer une méthode toString personnalisée.

Dans le JDK 14, le constructeur canonique devait être public. A partir du JDK 15, le constructeur canonique implicite obtient le même modificateur d'accès que la classe du record. Lors de la définition d'un constructeur canonique explicite, le modificateur d'accès doit fournir au moins autant d'accès que la classe du record.

Dans le cadre du changement, l'annotation @Override a également été modifiée. Il peut maintenant être utilisé pour annoter une méthode d'accès explicite dans un record.

L'article Pleins Feux Sur Une Fonctionnalité De Java 14 : Les Records, écrit par Brian Goetz, fournit plus de détails et d'exemples sur les records.

En ce qui concerne le pattern matching pour l'instruction instanceof, vérifier si un objet était d'un certain type puis l'utiliser était toujours un processus en deux étapes. Tout d'abord, instanceof a été utilisé pour vérifier si l'argument était du type correct, puis l'objet a été casté en ce type spécifique. Après cela, des méthodes spécifiques à un objet peuvent être appelées telles que la méthode pay() sur un Customer :

if (person instanceof Customer) {
    Customer customer = (Customer) person;
    customer.pay();
}

Avec la nouvelle fonctionnalité de pattern matching, il est possible d'écrire la même fonctionnalité sous une forme plus compacte. Dans ce cas, customer est ce que l'on appelle la variable du pattern. Une variable du pattern est dans la portée lorsqu'elle est correctement mise en correspondance :

if (person instanceof Customer customer) {
    customer.pay();
}

Désormais, le pattern matching réduit principalement le code boilerplate. Cependant, cette fonctionnalité sera utilisée pour les expressions switch dans une future version Java.

Les variables du pattern peuvent masquer les champs. Par exemple, la variable du pattern customer peut masquer le champ customer :

// champs customer dans la portée
if (person instanceof Customer customer) {
    // customer fait référence à la variable du pattern
} else {
    // customer fait référence au champs
}

L'expression de type pattern matching pour l'instruction instanceof peut être combinée avec d'autres expressions pour écrire des méthodes plus compactes telles que la méthode equals :

@Override
public boolean equals(Object o) {
    return o instanceof Customer other &&
            name.equals(other.name);
}

Au lieu de l'ancienne manière :

@Override
public boolean equals(Object o) {
    if (o instanceof Customer) {
        Customer other = (Customer) o;
        if (name.equals(other.name)) {
            return true;
        }
    }
    return false;
}