次の例では、Rectangleレコード・クラスの標準コンストラクタを明示的に宣言します。lengthおよびwidthがゼロより大きいことを検証します。そうでない場合は、IllegalArgumentExceptionをスローします:

record Rectangle(double length, double width) {
    public Rectangle(double length, double width) {
        if (length <= 0 || width <= 0) {
            throw new java.lang.IllegalArgumentException(
                String.format("Invalid dimensions: %f, %f", length, width));
        }
        this.length = length;
        this.width = width;
    }
}

標準コンストラクタのシグネチャでレコード・クラスのコンポーネントを繰り返すと、退屈でエラーが発生しやすくなります。これを回避するには、シグネチャが暗黙的な(コンポーネントから自動的に導出される)コンパクト・コンストラクタを宣言します。

たとえば、次のコンパクト・コンストラクタ宣言では、前の例と同じ方法で、lengthおよびwidthを検証します:

record Rectangle(double length, double width) {
    public Rectangle {
        if (length <= 0 || width <= 0) {
            throw new java.lang.IllegalArgumentException(
                String.format("Invalid dimensions: %f, %f", length, width));
        }
    }
}

この簡潔な形式のコンストラクタ宣言は、レコード・クラスでのみ使用できます。標準コンストラクタに現れる文this.length = length;およびthis.width = width;は、コンパクト・コンストラクタには現れないことに注意してください。コンパクト・コンストラクタの最後に、その暗黙的仮パラメータが、そのコンポーネントに対応するレコード・クラスのprivateフィールドに割り当てられます。

引数リストがレコードの型パラメータと一致しない、代替の非標準コンストラクタを定義できます。ただし、これらのコンストラクタは、レコードの標準コンストラクタを呼び出す必要があります。次の例では、レコードRectanglePairのコンストラクタに、1つのパラメータPair<Float>が含まれています。暗黙的に定義された標準コンストラクタを呼び出して、フィールドlengthおよびwidthを初期化します:

record Pair<T extends Number>(T x, T y) { }

record RectanglePair(double length, double width) {
    public RectanglePair(Pair<Double> corner) {
        this(corner.x().doubleValue(), corner.y().doubleValue());
    }
}

レコード・クラスのコンポーネントに対応するpublicアクセッサ・メソッドなど、ヘッダーから導出された任意のメンバーを明示的に宣言できます。たとえば:

record Rectangle(double length, double width) {
 
    // Public accessor method
    public double length() {
        System.out.println("Length is " + length);
        return length;
    }
}

独自のアクセッサ・メソッドを実装する場合は、暗黙的に導出されるアクセッサと同じ特性を持っていることを確認します(たとえば、publicと宣言され、対応するレコード・クラス・コンポーネントと同じ戻り型を持っていること)。同様に、独自のバージョンのequals、hashCodeおよびtoStringメソッドを実装する場合は、すべてのレコード・クラスの共通スーパークラスであるjava.lang.Recordクラスの特性および動作と同じであることを確認します。

次の例のように、静的フィールド、静的イニシャライザおよび静的メソッドをレコード・クラスで宣言でき、これらは標準クラスの場合と同様に動作します。たとえば:

record Rectangle(double length, double width) {
    
    // Static field
    static double goldenRatio;

    // Static initializer
    static {
        goldenRatio = (1 + Math.sqrt(5)) / 2;
    }

    // Static method
    public static Rectangle createGoldenRectangle(double width) {
        return new Rectangle(width, width * goldenRatio);
    }
}

インスタンス変数(静的でないフィールド)またはインスタンス・イニシャライザは、レコード・クラスで宣言できません。

たとえば、次のレコード・クラス宣言はコンパイルされません:

record Rectangle(double length, double width) {

    // Field declarations must be static:
    BiFunction<Double, Double, Double> diagonal;

    // Instance initializers are not allowed in records:
    {
        diagonal = (x, y) -> Math.sqrt(x*x + y*y);
    }
}

独自のアクセッサ・メソッドを実装するかどうかに関係なく、レコード・クラスでインスタンス・メソッドを宣言できます。ネストされたクラスおよびインタフェースは、ネストされたレコード・クラス(暗黙的に静的)を含めて、レコード・クラスで宣言することもできます。たとえば:

record Rectangle(double length, double width) {

    // Nested record class
    record RotationAngle(double angle) {
        public RotationAngle {
            angle = Math.toRadians(angle);
        }
    }
    
    // Public instance method
    public Rectangle getRotatedRectangleBoundingBox(double angle) {
        RotationAngle ra = new RotationAngle(angle);
        double x = Math.abs(length * Math.cos(ra.angle())) +
                   Math.abs(width * Math.sin(ra.angle()));
        double y = Math.abs(length * Math.sin(ra.angle())) +
                   Math.abs(width * Math.cos(ra.angle()));
        return new Rectangle(x, y);
    }
}

レコード・クラスではnativeメソッドを宣言できません。

レコード・クラスは暗黙的にfinalであるため、明示的に拡張できません。ただし、これらの制限事項を除けば、レコード・クラスは通常のクラスと同様に動作します:

• 汎用レコード・クラスを作成できます。たとえば:

  record Triangle<C extends Coordinate> (C top, C left, C right) { }

• 1つ以上のインタフェースを実装するレコード・クラスを宣言できます。たとえば:

  record Customer(...) implements Billable { }

• レコード・クラスとその個々のコンポーネントに注釈を付けることができます。たとえば:

  import java.lang.annotation.*;
  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.FIELD)
  public @interface GreaterThanZero { }

  record Rectangle(
      @GreaterThanZero double length,
      @GreaterThanZero double width) { }

  レコード・コンポーネントに注釈を付けると、注釈がレコード・クラスのメンバーおよびコンストラクタに伝播される場合があります。この伝播は、注釈インタフェースが適用可能なコンテキストによって決まります。前述の例では、@Target(ElementType.FIELD)というメタ注釈は、@GreaterThanZeroという注釈がレコード・コンポーネントに対応するフィールドに伝播されることを意味します。したがって、このレコード・クラス宣言は、次の通常のクラス宣言と同等になります:

  public final class Rectangle {
      private final @GreaterThanZero double length;
      private final @GreaterThanZero double width;
      
      public Rectangle(double length, double width) {
          this.length = length;
          this.width = width;
      }
      
      double length() { return this.length; }
      double width() { return this.width; }
  }

レコード・クラスは、シール・クラスおよびインタフェースを適切に処理します。例については、許可されたサブクラスとしてのレコード・クラスを参照してください。

ローカル・レコード・クラスはローカル・クラスに似ていますが、メソッド本体で定義されたレコード・クラスです。

次の例では、業者はレコード・クラスMerchantでモデル化されています。業者による販売も、レコード・クラスSaleを使用してモデル化されています。MerchantとSaleはどちらも最上位のレコード・クラスです。業者とその月間売上合計の集計は、findTopMerchantsメソッド内で宣言されるローカル・レコード・クラスMonthlySalesを使用してモデル化されています。このローカル・レコード・クラスにより、後続のストリーム操作が読みやすくなります:

import java.time.*;
import java.util.*;
import java.util.stream.*;

record Merchant(String name) { }

record Sale(Merchant merchant, LocalDate date, double value) { }

public class MerchantExample {
    
    List<Merchant> findTopMerchants(
        List<Sale> sales, List<Merchant> merchants, int year, Month month) {
    
        // Local record class
        record MerchantSales(Merchant merchant, double sales) {}

        return merchants.stream()
            .map(merchant -> new MerchantSales(
                merchant, this.computeSales(sales, merchant, year, month)))
            .sorted((m1, m2) -> Double.compare(m2.sales(), m1.sales()))
            .map(MerchantSales::merchant)
            .collect(Collectors.toList());
    }   
    
    double computeSales(List<Sale> sales, Merchant mt, int yr, Month mo) {
        return sales.stream()
            .filter(s -> s.merchant().name().equals(mt.name()) &&
                s.date().getYear() == yr &&
                s.date().getMonth() == mo)
            .mapToDouble(s -> s.value())
            .sum();
    }    

    public static void main(String[] args) {
        
        Merchant sneha = new Merchant("Sneha");
        Merchant raj = new Merchant("Raj");
        Merchant florence = new Merchant("Florence");
        Merchant leo = new Merchant("Leo");
        
        List<Merchant> merchantList = List.of(sneha, raj, florence, leo);
        
        List<Sale> salesList = List.of(
            new Sale(sneha,    LocalDate.of(2020, Month.NOVEMBER, 13), 11034.20),
            new Sale(raj,      LocalDate.of(2020, Month.NOVEMBER, 20),  8234.23),
            new Sale(florence, LocalDate.of(2020, Month.NOVEMBER, 19), 10003.67),
            // ...
            new Sale(leo,      LocalDate.of(2020, Month.NOVEMBER,  4),  9645.34));
        
        MerchantExample app = new MerchantExample();
        
        List<Merchant> topMerchants =
            app.findTopMerchants(salesList, merchantList, 2020, Month.NOVEMBER);
        System.out.println("Top merchants: ");
        topMerchants.stream().forEach(m -> System.out.println(m.name()));
    }
}

ネストされたレコード・クラスと同様に、ローカル・レコード・クラスは暗黙的に静的です。つまり、静的でないローカル・クラスとは異なり、独自のメソッドは包含するメソッドの変数にアクセスできません。

Java SE 16より前の場合、メンバーが定数変数でないかぎり、内部クラスで明示的または暗黙的に静的メンバーを宣言できませんでした。つまり、ネストされたレコード・クラスは暗黙的に静的であるため、内部クラスでレコード・クラス・メンバーは宣言できません。

Java SE 16以降では、内部クラスで、レコード・クラス・メンバーを含め、明示的または暗黙的に静的なメンバーを宣言できます。その方法を示すサンプル・コードを次に示します。

public class ContactList {
    
    record Contact(String name, String number) { }
    
    public static void main(String[] args) {
        
        class Task implements Runnable {
            
            // Record class member, implicitly static,
            // declared in an inner class
            Contact c;
            
            public Task(Contact contact) {
                c = contact;
            }
            public void run() {
                System.out.println(c.name + ", " + c.number);
            }
        }        
        
        List<Contact> contacts = List.of(
            new Contact("Sneha", "555-1234"),
            new Contact("Raj", "555-2345"));
        contacts.stream()
                .forEach(cont -> new Thread(new Task(cont)).start());
    }
}

レコード・クラスのインスタンスはシリアライズおよびデシリアライズできますが、writeObject、readObject、readObjectNoData、writeExternalまたはreadExternalメソッドを提供してプロセスをカスタマイズすることはできません。レコード・クラスのコンポーネントはシリアライズを制御し、レコード・クラスの標準コンストラクタはデシリアライズを制御します。

レコードは、通常のシリアライズ可能オブジェクトとは異なる方法でシリアライズされます。レコード・オブジェクトの直列化形式は、レコード・コンポーネントから導出された値のシーケンスです。レコード・オブジェクトがデシリアライズされると、コンポーネント値がこの値シーケンスから再構築されます。その後、コンポーネント値を引数として指定し、レコードの標準コンストラクタを呼び出すことで、レコード・オブジェクトが作成されます。対照的に、通常のオブジェクトがデシリアライズされた場合は、そのコンストラクタのいずれかを呼び出さなくても、通常のオブジェクトを作成できます。したがって、シリアライズ可能なレコードは、レコード・クラスによって提供される保証を利用して、よりシンプルでセキュアなシリアライズ・モデルを提供します。

abstractクラスjava.lang.Recordは、すべてのレコード・クラスの共通スーパークラスです。

ソース・ファイルがjava.lang以外のパッケージからRecordという名前のクラスをインポートすると、コンパイラ・エラーが発生する場合があります。Javaソース・ファイルは、暗黙的なimport java.lang.*;文を介して、java.langパッケージ内のすべての型を自動的にインポートします。これには、プレビュー機能が有効か無効かに関係なく、java.lang.Recordクラスが含まれます。

package com.myapp;

public class Record {
    public String greeting;
    public Record(String greeting) {
        this.greeting = greeting;
    }
}

次の例では、org.example.MyappPackageExampleはワイルドカードを使用してcom.myapp.Recordをインポートしますが、コンパイルは行いません:

package org.example;
import com.myapp.*;

public class MyappPackageExample {
    public static void main(String[] args) {
       Record r = new Record("Hello world!");
    }
}

コンパイラは、次のようなエラーメッセージを生成します:

./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous
       Record r = new Record("Hello world!");
       ^
  both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match

./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous
       Record r = new Record("Hello world!");
                      ^
  both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match

com.myappパッケージのRecordとjava.langパッケージのRecordは、ワイルドカードを使用してインポートされます。したがって、どちらのクラスも優先されず、コンパイラは単純な名前Recordの使用を検出するとエラーを生成します。

この例をコンパイルできるようにするには、Recordの完全修飾名をインポートするようにimport文を変更します:

import com.myapp.Record;

クラスjava.lang.Classには、レコード・クラスに関連する次の2つのメソッドがあります:

• RecordComponent[] getRecordComponents(): レコード・クラスのコンポーネントに対応するjava.lang.reflect.RecordComponentオブジェクトの配列を返します。
• boolean isRecord(): クラスがレコード・クラスとして宣言された場合にtrueを返すことを除き、isEnum()に似ています。