Sintaxis y propósito de los records

Los records son un tipo especial de clase para representar datos inmutables de manera concisa. Actúan como portadores de datos transparentes, reduciendo el código repetitivo que tradicionalmente se necesita para clases que simplemente almacenan valores.

Sirven para simplificar el desarrollo de clases que principalmente sirven como contenedores de datos, sin sacrificar la seguridad de tipos ni las convenciones de la programación orientada a objetos.

Se declara mediante la palabra clave record seguida del nombre y una lista de componentes (parámetros) entre paréntesis:

record Punto(int x, int y) { }

Con esta simple declaración, Java genera automáticamente:

• Un constructor canónico que inicializa todos los campos
• Métodos de acceso (getters) para cada campo con el mismo nombre del campo
• Implementaciones adecuadas de los métodos equals(), hashCode() y toString()

El propósito principal de los records es eliminar el código boilerplate asociado con las clases de datos. Por ejemplo, esta única línea de código equivale a escribir manualmente alrededor de 50-60 líneas de código en una clase tradicional.

Los records son siempre inmutables, lo que significa que una vez creado un record, sus valores no pueden cambiar. Esta característica los hace ideales para:

• Transferencia de datos entre métodos o sistemas
• Representación de valores inmutables en el dominio
• Mensajes en sistemas distribuidos
• Tuplas y agrupaciones de valores relacionados

Un ejemplo de uso sería:

Punto p = new Punto(5, 10);
System.out.println(p); // Imprime: Punto[x=5, y=10]
System.out.println(p.x()); // Accede al valor x: 5
System.out.println(p.y()); // Accede al valor y: 10

Punto p2 = new Punto(5, 10);
System.out.println(p.equals(p2)); // true - comparación basada en valores

La inmutabilidad de los records tiene ventajas:

• Son thread-safe por diseño
• Crean objetos predecibles y confiables
• Simplifican el razonamiento sobre el código
• Son ideales como claves en estructuras de datos como HashMap

Comparación con clases tradicionales

Para entender el valor de los records, se puede comparar con el enfoque tradicional de crear clases para datos inmutables. En el siguiente ejemplo:

Clase tradicional:

public final class PuntoTradicional {
    private final int x;
    private final int y;
    
    public PuntoTradicional(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() {
        return x;
    }
    
    public int getY() {
        return y;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PuntoTradicional that = (PuntoTradicional) o;
        return x == that.x && y == that.y;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
    
    @Override
    public String toString() {
        return "PuntoTradicional[x=" + x + ", y=" + y + "]";
    }
}

Record equivalente:

record Punto(int x, int y) { }

Las diferencias clave incluyen:

• Concisión: Los records eliminan prácticamente todo el código boilerplate
• Getters: En records, los métodos de acceso usan el mismo nombre que el componente (sin el prefijo "get")
• Inmutabilidad obligatoria: Los records son siempre inmutables, mientras que en clases tradicionales esto debe implementarse manualmente
• Constructores: El constructor canónico se genera automáticamente para records
• equals/hashCode/toString: Estos métodos se generan automáticamente con implementaciones

Además, los records tienen algunas restricciones estructurales:

• No pueden extender otras clases (implícitamente extienden java.lang.Record)
• Son implícitamente final (no pueden ser extendidos)
• Sus campos son implícitamente final (inmutables)
• No pueden declarar campos de instancia adicionales (solo estáticos)

Personalización: constructores, métodos adicionales

Constructores personalizados

Los records admiten dos tipos de constructores:

• Constructor compacto: para validación y restricciones:

record Empleado(String nombre, int edad) {
    // Constructor compacto - no necesita asignaciones 
    public Empleado {
        if (edad < 18) {
            throw new IllegalArgumentException("Debe ser mayor de edad");
        }
        if (nombre == null || nombre.isBlank()) {
            throw new IllegalArgumentException("El nombre no puede estar vacío");
        }
    }
}

• Constructor canónico explícito: control total sobre la inicialización:

record Rectangulo(double ancho, double alto, double area) {
    // Constructor canónico explícito
    public Rectangulo(double ancho, double alto) {
        this(ancho, alto, ancho * alto);
    }
    
    // Constructor canónico completo
    public Rectangulo(double ancho, double alto, double area) {
        this.ancho = ancho;
        this.alto = alto;
        this.area = area;
    }
}

Métodos adicionales

Los records pueden contener métodos de instancia adicionales para proporcionar comportamiento relacionado con sus datos:

record Circulo(double radio) {
    public double area() {
        return Math.PI * radio * radio;
    }
    
    public double perimetro() {
        return 2 * Math.PI * radio;
    }
}

También pueden incluir métodos estáticos, incluyendo métodos de fábrica:

record Color(int r, int g, int b) {
    // Validación en constructor compacto
    public Color {
        if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
            throw new IllegalArgumentException("Valores RGB deben estar entre 0 y 255");
        }
    }
    
    // Métodos estáticos (fábricas)
    public static Color rojo() {
        return new Color(255, 0, 0);
    }
    
    public static Color verde() {
        return new Color(0, 255, 0);
    }
    
    public static Color azul() {
        return new Color(0, 0, 255);
    }
    
    // Método de instancia
    public Color mezclar(Color otro) {
        return new Color(
            (r + otro.r) / 2,
            (g + otro.g) / 2,
            (b + otro.b) / 2
        );
    }
}

Personalización de métodos generados

También se pueden personalizar los métodos generados automáticamente:

record Producto(String nombre, double precio) {
    // Personalización de toString
    @Override
    public String toString() {
        return nombre + " - $" + String.format("%.2f", precio);
    }
    
    // Personalización de equals para comparación insensible a mayúsculas
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Producto other = (Producto) obj;
        return precio == other.precio && 
               nombre.equalsIgnoreCase(other.nombre);
    }
    
    // Si personaliza equals, también debe personalizar hashCode
    @Override
    public int hashCode() {
        return Objects.hash(nombre.toLowerCase(), precio);
    }
}

Limitaciones y casos de uso óptimos

Los records tienen algunas limitaciones importantes que deben considerarse:

• Inmutabilidad obligatoria: No se pueden modificar los valores después de la creación
• Sin herencia de clases: No pueden extender otras clases
• Campos de instancia limitados: Solo pueden tener los campos declarados en el encabezado
• Siempre finales: No pueden ser extendidos por otras clases
• Compatibilidad con serialización: Tienen un esquema de serialización específico

Estas limitaciones definen dónde los records son más apropiados.

Casos de uso ideales

• Transferencia de datos (DTOs):

record UserResponse(long id, String username, String email) { }

• Objetos de valor inmutables:

record Dinero(BigDecimal cantidad, String moneda) { }

• Resultados múltiples de un método:

record EstadisticasArchivo(long tamaño, long lineas, long palabras) { }

public EstadisticasArchivo analizarArchivo(Path ruta) {
    // Procesar archivo y devolver múltiples valores
    return new EstadisticasArchivo(1024, 42, 512);
}

• Tuplas con semántica:

record Coordenada(double latitud, double longitud) { }

• Parámetros de eventos:

record EventoUsuario(Instant tiempo, String usuarioId, String tipoAccion) { }

• Agrupación de entradas de configuración:

record ConfiguracionDatabase(
    String url, 
    String usuario, 
    String contraseña, 
    int maxConexiones
) { }

• Registros anidados para estructuras de datos complejas:

record Dirección(String calle, String ciudad, String codigoPostal, String país) { }
record Cliente(String nombre, String email, Dirección dirección) { }

• Registros genéricos para contenedores de datos tipados:

record Par<K, V>(K clave, V valor) { }

// Uso
Par<String, Integer> entrada = new Par<>("edad", 25);

Cuando evitar records

Los records no son adecuados cuando:

• Se necesita mutabilidad (cambiar valores después de la creación)
• Se requiere herencia de clases
• El objeto necesita mantener un estado interno más allá de sus componentes públicos
• Se requiere un control preciso sobre la representación física de los datos
• Se necesitan invariantes complejos entre múltiples campos que no pueden mantenerse solo con inmutabilidad

En estos casos, es mejor usar clases tradicionales con la estructura apropiada. Por ejemplo:

// Caso para una clase tradicional: mutabilidad necesaria
public class Contador {
    private int valor;
    
    public Contador(int valorInicial) {
        this.valor = valorInicial;
    }
    
    public int getValor() {
        return valor;
    }
    
    public void incrementar() {
        valor++;
    }
    
    public void decrementar() {
        valor--;
    }
}