record

// Define a record. The components in parentheses become the fields.
record RecordName(Type field1, Type field2) {
    // You can also define additional methods here.
}

// Use a compact constructor (omitting the parameter list) to add validation.
record Point(int x, int y) {
    Point {
        if (x < 0 || y < 0) throw new IllegalArgumentException("Coordinates must be 0 or greater.");
    }
}

// Accessor methods share the same name as the component (no "get" prefix).
Point p = new Point(3, 4);
int x = p.x(); // Access the x field via x().
int y = p.y();

// A record is a final class and cannot be extended, but it can implement interfaces.
record Range(int start, int end) implements Comparable<Range> {
    @Override
    public int compareTo(Range other) { return Integer.compare(start, other.start); }
}

sample_RecordExample.java

record Point(int x, int y) {}

record Person(String name, int age) {
    Person {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name cannot be blank.");
        if (age < 0) throw new IllegalArgumentException("age must be 0 or greater.");
    }

    // Define an additional method.
    String greeting() {
        return "Hello, I'm " + name + " (" + age + " years old).";
    }
}

record Temperature(double celsius) {
    double toFahrenheit() { return celsius * 9 / 5 + 32; }
}

class RecordExample {
    public static void main(String[] args) {
        // Define and use a simple record.
        Point p1 = new Point(3, 4);
        Point p2 = new Point(3, 4);

        System.out.println(p1.x()); // Prints "3".
        System.out.println(p1.y()); // Prints "4".
        System.out.println(p1); // Prints "Point[x=3, y=4]".
        System.out.println(p1.equals(p2)); // Prints "true".

        // Define a record with validation.
        Person iori = new Person("Yagami Iori", 20);
        System.out.println(iori.greeting()); // Prints "Hello, I'm Yagami Iori (20 years old).".

        // Implement an interface.
        Temperature t = new Temperature(100.0);
        System.out.println(t.toFahrenheit()); // Prints "212.0".
    }
}

RecordExample.java

javac RecordExample.java
java RecordExample
3
4
Point[x=3, y=4]
true
Hello, I'm Yagami Iori (20 years old).
212.0

A record is a syntax for defining "data classes" whose sole purpose is to hold data. Traditionally, this required a large amount of boilerplate code (constructors, getters, equals(), and so on), but with records you can define everything in a single line.

All fields in a record are immutable (final), so the values of an instance cannot be changed after it is created. A record is implicitly a final class and cannot be extended, but it can implement interfaces.

For a comparison with enums, see enum. For the basics of class definitions, see class / new / Constructor / this.