Es scheint, dass Java 14 Datenklassen-ähnliche Funktionen hinzufügen wird

Viele Leute haben Klassen in Java geschrieben, die nur Felder, Konstruktoren und Getters enthalten (Setter, equals, toString in einigen Fällen). Solche Klassen werden Datenklassen genannt. In einigen Fällen müssen Sie viele ähnliche Klassen schreiben, und egal wie oft Sie die Methodengenerierungsfunktion der IDE verwenden, es ist ärgerlich. Wenn Sie Lombok verwenden, wird dies bis zu einem gewissen Grad gelindert, aber in vielen Fällen müssen Sie die IDE usw. einstellen, und es wird immer noch problematisch sein.

In der Zwischenzeit scheint Java 14 eine Funktion zur Lösung dieses Problems hinzuzufügen.

Was ist neu in Java 14?

Java 14 führt etwas namens "Record" ein. https://blogs.oracle.com/javamagazine/records-come-to-java

Die Verwendung scheint die Klasse, für die Sie eine Datenklasse sein möchten, als "Datensatz" anstelle von "Klasse" zu deklarieren.

Anwendungsbeispiel

vor Gebrauch

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 +
                '}';
    }
}

Ich bin es leid, viele Getters, Konstruktoren und Override-Methoden nebeneinander zu sehen. Dies ist, was Java 14 tut.

FXOrder.java

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

~~ Wie Kotlin ~~ Sie werden feststellen, dass Sie es sehr ordentlich deklarieren können. Es scheint jedoch, dass Setter nicht vorbereitet ist. Seien Sie also vorsichtig, wenn Sie OR Mapper usw. verwenden.

Zusammenfassung

~~ Ich denke Kotlin ist okay ~~ Es scheint, dass Java 14 eine leistungsstarke neue Funktion namens "Record" einführen wird. Damit scheint es, dass Legacy-Code präzise umgeschrieben werden kann. Persönlich möchte ich diese Funktion auf jeden Fall nutzen und denke über ein Update von Java 8 nach!