Enhanced JEP 395: Records (Standardized)

Java 16 introduced JEP 395: Records as an incubated feature, and with Java 17, this feature was standardized. Records provide a new way to model immutable data structures with less boilerplate code. They are a special type of class designed to hold data without needing the user to write code for typical methods such as constructors, getters, equals(), hashCode(), and toString().

The main goal of Records is to simplify code by automatically providing the standard functionality required for simple data-carrying classes, such as value objects or data transfer objects (DTOs).

What Are Records?

A Record in Java is a special kind of class that primarily focuses on storing immutable data. It is designed to reduce the verbosity of creating simple POJOs (Plain Old Java Objects).

Before records, developers had to manually write the following for a simple data object:

• A constructor to initialize the fields.
• Getter methods to access the fields.
• equals() and hashCode() methods to compare instances.
• toString() method to provide a string representation of the object.

With records, Java automatically generates all of these methods for you.

Syntax of Records

A record is defined using the record keyword:

public record Person(String name, int age) { }Code language: JavaScript (javascript)

In the above example:

• Person is a record with two fields: name (a String) and age (an int).
• Java automatically provides a constructor, getters, equals(), hashCode(), and toString() methods.

You can also define additional methods and customize some behavior within the record if needed.

public class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}Code language: PHP (php)

Java 17 Record:

<strong>public record Person(String name, int age) { }</strong>Code language: HTML, XML (xml)

Notice how the record definition is significantly more concise, with no need to write getters, constructors, equals(), hashCode(), or toString(). Java automatically provides these methods when the record is compiled.

Additional Capabilities

While records are designed for simplicity, they still offer flexibility and can be extended in the following ways:

1. Custom Methods: You can define custom methods within a record to implement specific behavior.

public record Person(String name, int age) {
    public String greet() {
        return "Hello, my name is " + name;
    }
}Code language: JavaScript (javascript)

     2.Custom Constructors: You can also define a custom constructor if you need some additional logic when creating the

       record instance.

public record Person(String name, int age) {
    public Person {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
    }
}Code language: PHP (php)

  3.   Implements Interfaces: Records can implement interfaces just like regular classes.

public record Person(String name, int age) implements Comparable<Person> {
    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }
}Code language: JavaScript (javascript)