Il semble que Java 14 ajoutera des fonctions de type classe de données

Beaucoup de gens ont écrit des classes en Java qui n'ont que des champs, des constructeurs et des Getters (Setter, equals, toString dans certains cas). Ces classes sont appelées classes de données. Dans certains cas, vous devez écrire beaucoup de classes similaires, et peu importe à quel point vous utilisez la fonction de génération de méthode de l'EDI, c'est ennuyeux. L'utilisation de lombok le soulagera dans une certaine mesure, mais cela reste problématique car il existe de nombreux cas où vous devez définir l'EDI.

Pendant ce temps, il semble que Java 14 ajoutera une fonction pour résoudre ce problème.

Nouveautés de Java 14

Java 14 introduit quelque chose appelé «Record». https://blogs.oracle.com/javamagazine/records-come-to-java

L'utilisation semble déclarer la classe que vous voulez être une classe de données comme record au lieu de class.

Exemple d'utilisation

Avant utilisation

FXOrderClassc.java

public final class FXOrderClassic {
    private final int units;
    private final CurrencyPair pair;
    private final Side side;
    private final double price;
    private final LocalDateTime sentAt;
    private final int ttl;

    public FXOrderClassic(int units, 
               CurrencyPair pair, 
               Side side, 
               double price, 
               LocalDateTime sentAt, 
               int ttl) {
        this.units = units;
        this.pair = pair; // CurrencyPair is a simple enum
        this.side = side; // Side is a simple enum
        this.price = price;
        this.sentAt = sentAt;
        this.ttl = ttl;
    }

    public int units() {
        return units;
    }

    public CurrencyPair pair() {
        return pair;
    }

    public Side side() {
        return side;
    }

    public double price() { return price; }

    public LocalDateTime sentAt() {
        return sentAt;
    }

    public int ttl() {
        return ttl;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) 
            return false;

        FXOrderClassic that = (FXOrderClassic) o;

        if (units != that.units) return false;
        if (Double.compare(that.price, price) != 0) 
            return false;
        if (ttl != that.ttl) return false;
        if (pair != that.pair) return false;
        if (side != that.side) return false;
        return sentAt != null ? 
            sentAt.equals(that.sentAt) : that.sentAt == null;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = units;
        result = 31 * result + 
                   (pair != null ? pair.hashCode() : 0);
        result = 31 * result + 
                   (side != null ? side.hashCode() : 0);
        temp = Double.doubleToLongBits(price);
        result = 31 * result + 
                   (int) (temp ^ (temp >>> 32));
        result = 31 * result + 
                   (sentAt != null ? sentAt.hashCode() : 0);
        result = 31 * result + ttl;
        return result;
    }

    @Override
    public String toString() {
        return "FXOrderClassic{" +
                "units=" + units +
                ", pair=" + pair +
                ", side=" + side +
                ", price=" + price +
                ", sentAt=" + sentAt +
                ", ttl=" + ttl +
                '}';
    }
}

Je suis fatigué de voir beaucoup de Getters, de constructeurs et de méthodes Override côte à côte. C'est ce que fait Java 14.

FXOrder.java

public record FXOrder(int units,
                      CurrencyPair pair,
                      Side side,
                      double price,
                      LocalDateTime sentAt,
                      int ttl) {}

~~ Comme Kotlin ~~ Vous constaterez que vous serez en mesure de le déclarer très proprement. Cependant, il semble que Setter ne soit pas préparé, alors soyez prudent lorsque vous utilisez OR mapper etc.

Résumé

~~ Je pense que Kotlin va bien ~~ Il semble que Java 14 introduira une nouvelle fonctionnalité puissante appelée Record. Avec cela, il semble que le code hérité puisse être réécrit de manière concise. Personnellement, je souhaite vraiment utiliser cette fonctionnalité et je pense mettre à jour à partir de Java 8!