La JEP 405, Record Patterns (Preview), a été promue de Proposed to Target à Targeted pour le JDK 19. Sous l'égide du projet Amber, cette JEP propose d'améliorer le langage avec des record patterns pour déconstruire les valeurs de records. Les record patterns peuvent être utilisés en conjonction avec les type patterns pour "permettre une forme robuste, déclarative et composable de navigation et de traitement des données. Il s'agit toujours d'une fonctionnalité en preview.
La JEP 394, Pattern Matching for instanceof, livrée dans le JDK 16, a étendu l'opérateur instanceof pour prendre un type pattern et effectuer un pattern matching. Considérez l'exemple suivant :
public void print(Object o) {
if (o instanceof Double) {
Double d = (Double) o;
System.out.println("d = " + d);
}
}
Le code ci-dessus pourrait être écrit en utilisant le pattern matching comme suit :
public void print(Object o) {
if (o instanceof Double d) {
System.out.println("d = " + d);
}
}
Dans le code ci-dessus, o correspond au type pattern Double d si, au moment de l'exécution, la valeur de o est une instance de Double. Cela réduit le transtypage explicite et rend le code plus court et plus facile à gérer.
La JEP 395, Records, a introduit les classes Record, un support transparent de données qui permet aux développeurs d'écrire facilement des objets immuables. Considérez l'exemple suivant :
record Point(int x, int y) { }
Avec cela, les développeurs ne sont plus obligés d'écrire explicitement un constructeur, des méthodes d'accès et d'autres méthodes telles que toString() et hashCode(). Ainsi, le code devient propre et moins verbeux.
Si une instance d'une classe record est utilisée dans un bloc de code, les développeurs extraient généralement les données à l'aide de ses méthodes d'accès. Par exemple :
public void printSum(Object o) {
if (o instanceof Point p) {
int x = p.x();
int y = p.y();
System.out.println(x + y);
}
}
Dans le code ci-dessus, la variable de pattern p est utilisée pour invoquer les méthodes d'accès x() et y() pour obtenir la valeur de x et y. Il n'y a pas d'autre utilisation de p ici. Dans le cas du record pattern, la variable p n'est plus requise.
Maintenant, le code ci-dessus peut être réécrit :
public void printSum(Object o) {
if (o instanceof Point(int x int y)) {
System.out.println(x + y);
}
}
De même, cela permet aux développeurs de déconstruire des graphes d'objets plus complexes. Considérez l'exemple de code suivant :
enum Color {RED, GREEN, BLUE}
record ColoredPoint(Point p, Color color) {}
record Point(int x, int y) {}
record Square(ColoredPoint upperLeft, ColoredPoint lowerRight) {}
Si les développeurs ont besoin d'afficher le ColoredPoint supérieur gauche dans un scénario de pattern matching à l'aide du Record pattern, il peut être déconstruit comme suit :
public void printUpperLeftColoredPoint(Square s) {
if (s instanceof Square(ColoredPoint(Point(var x, var y), var color), var leftRight))){
}
}
D'autre part, l'alternative au code déconstruit ci-dessus est beaucoup plus verbeuse.
De plus, les type patterns ont été étendus pour une utilisation dans les étiquettes de case de switch via la JEP 406, Pattern Matching for switch (Preview) (fournie dans le JDK 17), et la JEP 420, Pattern Matching for switch (Second Preview ) (fournie dans le JDK 18). Avec ceux-ci, une déconstruction similaire peut être utilisée dans l'instruction switch. Cependant, le travail sur cette JEP est toujours en cours, et il existe de nombreuses directions dans lesquelles il pourrait évoluer et s'étendre. Les développeurs enthousiastes peuvent consulter la liste de diffusion et rejoindre cette discussion.