Nel precedente post abbiamo parlato delle nuove features di JDK14 che dalla roadmap dovrebbe essere disponibile – in prima RC a Giugno 2020.

Tra le interessati features incluse, ricordiamo queste:

368: Text Blocks (Second Preview)
359: Records (Preview)

Text Block.

Feature presente in altri linguaggi (il solito Scala) consente di gestire una stringa multilinea, migliorando la leggibilità del codice.

Ad esempio:

public static String getQuery(){
    String query =
                    """
                    select *
                    from dummy
                    where dummy.field = """+12+"""
                    """;
    return query;
}

Records.

Nella jdk14 sarà introdotto un nuovo tipo di dichiarazione, il record.

Lo scopo del record è quello di avere una sintassi compatta per una sorta di classi ristrette (tipo gli enum) che non sono altro che trasparenti raccoglitori di dati immutabili. Un record ha

• un nome
• uno stato
• opzionalmente, un body

 Un record acquisisce in maniera automatica e meccanica:

• Un campo final e privato per ogni componente della descrizione di stato
• Un metodo pubblico per ogni componente dello stato, che consente di leggerne il valore con lo stesso nome e tipo del componente.
• Un costruttore pubblico, con la stessa signature dello stato che inizializza ogni argomento corrispondente.
• Implementazioni di equals and hashCode e toString

Da notare che nella specifica, Brian Goetz dichiara apertamente che non è in atto una guerra contro il boilerplate code 🙂

Nella specifica un record è dichiarato come:

record Range(int lo, int hi) {
  public Range {
    if (lo > hi)  /* referring here to the implicit constructor parameters */
      throw new IllegalArgumentException(String.format("(%d,%d)", lo, hi));
  }
}

Se si dovesse scrivere in Java 8, si dovrebbe scrivere:

public class Range {



    final int lo;
    final int hi;

    public Range(int lo, int hi) {
        if (lo > hi)  /* referring here to the implicit constructor parameters */
            throw new IllegalArgumentException(String.format("(%d,%d)", lo, hi));
        this.lo = lo;
        this.hi = hi;
    }

    public int getLo()
    {
        return lo;
    }

    public int getHi()
    {
        return hi;
    }

    
}

Nella specifica, Goetz scrive anche

Records go well with sealed types (JEP 360); records and sealed types taken together form a construct often referred to as algebraic data types. Further, records lend themselves naturally to pattern matching. Because records couple their API to their state description, we will eventually be able to derive deconstruction patterns for records as well, and use sealed type information to determine exhaustiveness in switch expressions with type patterns or deconstruction patterns.

Ma di questo ce ne occuperemo alla prossima puntata.