Si vous connaissez déjà les enregistrements en Java, vous trouverez peut-être son utilisation très similaire à celle des classes, mais il existe des différences importantes qui doivent être prises en considération. Dans cet article, nous allons voir les différences entre les enregistrements et les classes en Java. Si vous ne connaissez toujours pas les enregistrements, je vous recommande de lire mon article Enregistrements en Java : qu'est-ce qu'ils sont et comment les utiliser.

Immutabilité

Un objet immuable est un objet dont les attributs ne peuvent pas être modifiés une fois l'objet créé. Dans le cas des enregistrements, ceux-ci sont immuables, c'est-à-dire qu'une fois qu'un objet de type enregistrement a été créé, ses attributs ne peuvent plus être modifiés. D'un autre côté, une classe peut être ou non immuable, selon la manière dont elle est implémentée. Cette partie garantit l'intégrité des données et évite qu'elles ne soient accidentellement modifiées.

But

Les classes sont généralement écrites simplement pour stocker des données, telles que celles d'une requête de base de données ou les données d'un formulaire. Dans de nombreux cas, ces données sont immuables, puisqu'il faut garantir leur validité sans recourir à la synchronisation. Pour y parvenir, une classe est écrite avec les éléments suivants :

• Attributs privés pour chaque champ.
• Getters pour chaque champ.
• Un constructeur qui initialise tous les champs.
• Une méthode égale qui compare les objets pour vérifier leur égalité.
• Une méthode hashCode qui génère un code de hachage basé sur les champs.
• Une méthode toString qui génère une représentation sous forme de chaîne des champs.

Par exemple, si vous avez une classe Person avec deux attributs name et lastName, vous pouvez l'écrire comme suit :

public class Person {

    private final String name;
    private final String lastName;

    public Person(String name, String lastName) {
        this.name = name;
        this.lastName = lastName;
    }

    public String getName() {
        return name;
    }

    public String getLastName() {
        return lastName;
    }

    @Override
    public String toString() {
        return "Person{"   "name='"   name   '\''  
                ", lastName='"   lastName   '\''  
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person person)) return false;
        return Objects.equals(getName(), person.getName()) && Objects.equals(getLastName(), person.getLastName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getLastName());
    }
}

C'est une solution à la tâche, mais cela représente beaucoup de code pour ce qui est réellement nécessaire. Si la classe avait plus d'attributs, ce serait un code encore plus long à écrire, même si cela était fait avec l'aide d'un IDE ou d'un plugin comme GitHub Copilot. Une meilleure solution serait de déclarer notre classe comme classe de données, c'est-à-dire une classe qui stocke uniquement des données et n'a pas besoin d'avoir un comportement spécifique, et c'est là qu'interviennent les enregistrements.

De cette manière, la classe Person pourrait être réécrite sous la forme d'un enregistrement comme suit :

public record Person(String name, String lastName) { }

Cela génère automatiquement les méthodes equals, hashCode et toString, ainsi que les méthodes getter pour chacun des attributs.

Quelles sont les différences entre un enregistrement et une classe ?

• Immmuabilité : les enregistrements sont immuables, c'est-à-dire qu'une fois qu'un objet de type enregistrement a été créé, ses attributs ne peuvent pas être modifiés. Au lieu de cela, une classe peut ou non être immuable, selon la manière dont elle a été implémentée.
• Méthodes générées : Les enregistrements génèrent automatiquement les méthodes equals, hashCode et toString, ainsi que les méthodes getter pour chacun des attributs. Cependant, dans les classes, ces méthodes doivent être implémentées manuellement ou à l'aide d'un IDE.
• Utilisation en POO : les enregistrements ne peuvent pas hériter d'autres classes, ni être étendus par d'autres classes, mais ils peuvent implémenter des interfaces. D'un autre côté, les classes peuvent hériter des autres, être étendues et sont en général idéales pour couvrir les concepts de programmation orientée objet.
• Syntaxe : La syntaxe d'un enregistrement est plus simple que celle d'une classe, puisqu'elle peut être définie sur une seule ligne, alors qu'une classe nécessite plusieurs lignes de code.
• Objectif : Les enregistrements sont une structure qui ressemble à un DTO (Data Transfer Object), c'est-à-dire une classe qui permet de modéliser des données immuables, pour sa part une classe est une structure plus générale qui peut avoir un comportement et un état.

Quand utiliser un enregistrement et quand utiliser une classe ?

Si ce qui est requis est une structure de données immuable pour stocker les données et qu'aucune modification des attributs ne doit être apportée (elle est simplement considérée comme un objet pour transporter des informations). D'un autre côté, si vous avez besoin d'une structure plus générale dotée d'une logique unique et de méthodes spécifiques, d'une approche d'un paradigme orienté objet, de l'application de modèles de conception ou du travail avec JPA ou Hibernate, etc., alors vous devez utiliser une classe.

Extra : enregistrement avec des attributs mutables

Considérons l'exemple suivant, il y a deux enregistrements Product avec les attributs nom et prix, et Cart avec un seul attribut products de type ArrayList et quelques méthodes pour obtenir le nombre de produits et le total du panier.

package org.jordi.example;

public record Product(String name, double price) { }

package org.jordi.example;

import java.util.ArrayList;
import java.util.List;

public record Cart(List products) {

    public Cart() {
        this(new ArrayList());
    }

    public int getQuantity() {
        return this.products.size();
    }

    public double getTotal() {
        return this.products.stream().mapToDouble(Product::price).sum();
    }
}

Le problème dans ce cas est que chacun des enregistrement est immuable en soi, mais dans le cas de l'enregistrement Cart en ayant un attribut de type ArrayList et puisque par nature un ArrayList est mutable , vous pourrez modifier le contenu de la liste une fois l'enregistrement Cart instancié.

package org.jordi.example;

public class Main {
    public static void main(String[] args) {
        Product water = new Product("Water", 15);
        Product milk = new Product("Milk", 22);

        Cart cart = new Cart();
        cart.products().add(water);
        cart.products().add(milk);
        System.out.println("Price: "   cart.getTotal());

        cart.products().clear();
        System.out.println("Quantity: "   cart.getQuantity());
        System.out.println("Price: "   cart.getTotal());
    }
}

Le code ci-dessus se compile sans problème, puisque seul le contenu de la liste est modifié, mais l'attribut products lui-même n'est pas modifié. Ceci n'est qu'un exemple pour un cas particulier, ce qui n'est probablement pas nécessaire, mais il est bon de savoir que cela peut être fait.