Java: clases, records, interfaces y tipos sealed
Curso de Java en OpenJDK 26: el bug de equals sin hashCode que mete duplicados en un HashSet (10,000 de 10,000 veces), records, interfaces y switch sealed.
Serie: curso de Java 2/6 (principiante). Para quien ya sabe escribir un método main y ahora necesita diseñar sus propios tipos. Al terminar vas a poder elegir entre una clase, un record, una interface, una clase abstracta y una jerarquía sealed, y vas a conocer el único error de equals/hashCode que corrompe un HashSet sin hacer ruido.
Si estás en un bootcamp de backend, en tu primer trabajo en una startup que usa Spring o haciendo el proyecto final de la materia de POO en la universidad, declarar una clase no es el problema. Las preguntas que de verdad te quitan horas llegan después: ¿por qué mi set contiene el mismo elemento dos veces?, ¿por qué agregar un subtipo nuevo no dio ningún error?, ¿esto debería ser un record? Este curso las responde con código ejecutado en OpenJDK 26 (Temurin 26+35) sobre una Mac con Apple Silicon (M1 Pro), con los mensajes exactos de javac y una medición de cuánto cuesta un hashCode malo.
Igual que en el curso 1, cada ejemplo es un solo archivo que puedes ejecutar con java File.java.
Clases, constructores y encapsulamiento
Una clase junta el estado con las reglas que mantienen ese estado válido. Encapsular significa que esas reglas viven en un solo lugar: los campos son private, y la única forma de entrar es a través de métodos que revisan lo que reciben.
public class Account {
private final String owner;
private long balance; // minor units (cents, yen, won); never double
public Account(String owner, long initial) {
if (owner == null || owner.isBlank()) throw new IllegalArgumentException("owner is required");
if (initial < 0) throw new IllegalArgumentException("initial < 0: " + initial);
this.owner = owner;
this.balance = initial;
}
public Account(String owner) { this(owner, 0); } // constructor chaining
public void withdraw(long amount) {
if (amount <= 0) throw new IllegalArgumentException("amount must be > 0");
if (amount > balance) throw new IllegalStateException("insufficient: " + balance + " < " + amount);
balance -= amount;
}
public long balance() { return balance; }
public String owner() { return owner; }
public static void main(String[] args) {
Account a = new Account("kim", 1000);
a.withdraw(300);
System.out.println(a.owner() + " " + a.balance());
System.out.println(a);
a.withdraw(5000);
}
}
kim 700
Account@6f3b5d16
Exception in thread "main" java.lang.IllegalStateException: insufficient: 700 < 5000
at Account.withdraw(Account.java:15)
at Account.main(Account.java:26)
Tres cosas que notan los principiantes:
System.out.println(a)imprimióAccount@6f3b5d16: el nombre de la clase y un hash en hexadecimal que cambia en cada ejecución. Eso esObject.toString(). Solo obtienes algo legible si lo sobrescribes (o si usas un record, más abajo).- El código de otra clase que escriba
a.balance = 1_000_000;no compila:error: balance has private access in Account. Ese error es justamente el objetivo del encapsulamiento; la solución es un método comodeposit, no hacer público el campo. - En cuanto escribes cualquier constructor, Java deja de darte gratis el constructor sin argumentos.
new Point()sobre una clase que solo tienePoint(int x, int y)falló conerror: constructor Point in class Point cannot be applied to given types;seguido derequired: int,intyfound: no arguments.
El contrato equals/hashCode y el bug de duplicados en HashSet
HashSet y HashMap encuentran un elemento en dos pasos: hashCode() elige un bucket y luego equals() compara dentro de ese bucket. Por eso el contrato de la documentación de Object dice: si a.equals(b), entonces a.hashCode() == b.hashCode(). Si lo rompes, las colecciones se portan mal sin lanzar ninguna excepción.
import java.util.*;
public class HashBug {
static class P0 { final int x, y; P0(int x, int y) { this.x = x; this.y = y; } }
static class P1 { // equals overridden, hashCode forgotten
final int x, y;
P1(int x, int y) { this.x = x; this.y = y; }
@Override public boolean equals(Object o) {
return o instanceof P1 p && p.x == x && p.y == y;
}
}
static class P2 { // both, correctly
final int x, y;
P2(int x, int y) { this.x = x; this.y = y; }
@Override public boolean equals(Object o) {
return o instanceof P2 p && p.x == x && p.y == y;
}
@Override public int hashCode() { return Objects.hash(x, y); }
}
static class P3 { // correct, but mutable fields in hashCode
int x, y;
P3(int x, int y) { this.x = x; this.y = y; }
@Override public boolean equals(Object o) {
return o instanceof P3 p && p.x == x && p.y == y;
}
@Override public int hashCode() { return Objects.hash(x, y); }
}
public static void main(String[] args) {
Set<Object> s0 = new HashSet<>(List.of(new P0(1, 2), new P0(1, 2)));
Set<Object> s1 = new HashSet<>(); s1.add(new P1(1, 2)); s1.add(new P1(1, 2));
Set<Object> s2 = new HashSet<>(); s2.add(new P2(1, 2)); s2.add(new P2(1, 2));
System.out.println("no equals/hashCode : size=" + s0.size());
System.out.println("equals only : size=" + s1.size()
+ ", equals? " + new P1(1, 2).equals(new P1(1, 2))
+ ", contains? " + s1.contains(new P1(1, 2)));
System.out.println("equals + hashCode : size=" + s2.size()
+ ", contains? " + s2.contains(new P2(1, 2)));
int dup = 0;
for (int i = 0; i < 10_000; i++) {
Set<P1> s = new HashSet<>();
s.add(new P1(i, i)); s.add(new P1(i, i));
if (s.size() == 2) dup++;
}
System.out.println("equals only, 10,000 trials: duplicates in " + dup);
System.out.println("ArrayList.contains : "
+ new ArrayList<>(List.of(new P1(1, 2))).contains(new P1(1, 2)));
P3 p = new P3(1, 2);
Set<P3> s3 = new HashSet<>(); s3.add(p);
p.x = 99; // mutate after insertion
System.out.println("mutated key : contains(p)=" + s3.contains(p)
+ ", size=" + s3.size() + ", remove(p)=" + s3.remove(p));
}
}
no equals/hashCode : size=2
equals only : size=2, equals? true, contains? false
equals + hashCode : size=1, contains? true
equals only, 10,000 trials: duplicates in 10000
ArrayList.contains : true
mutated key : contains(p)=false, size=1, remove(p)=false
Lee la segunda línea con calma: equals dice que los dos puntos son iguales, pero el set guarda ambos y no encuentra un tercero igual. No es una falla ocasional; ocurrió en los 10,000 intentos, porque el hashCode por defecto es propio de cada objeto. Peor todavía: ArrayList.contains (que solo usa equals) devuelve true, así que un test escrito con una lista pasa y el bug aparece solo cuando alguien cambia a un set.
La última línea es la otra mitad del contrato: una clave cuyos campos de hash cambian después de insertarla se pierde. El set sigue teniendo tamaño 1, pero ni contains ni remove pueden alcanzarla.
javac puede detectar el primer error si se lo pides:
$ javac -Xlint:all HashBug.java
HashBug.java:8: warning: [overrides] Class P1 overrides equals, but neither it nor any superclass overrides hashCode method
Error común: equals(P o) en lugar de equals(Object o)
public boolean equals(P o) { return o != null && o.x == x; } // overload, not override
p.equals(p2) : true
o.equals(p2) : false // o is declared as Object
List.of(..).contains: false
Qué pasa: agregaste un método nuevo (una sobrecarga); las colecciones llaman a equals(Object) y siguen recibiendo la comparación de identidad heredada. Solución: escribe siempre @Override. Con esa anotación, javac rechaza la firma incorrecta: error: equals(P) in P does not override or implement a method from a supertype.
Cuánto cuesta un hashCode malo
Un hashCode que devuelve una constante es legal: los objetos iguales sí reciben hashes iguales. Solo que mete todas las claves en un mismo bucket. Agregamos n claves a un HashSet y luego buscamos cada una, comparando el hashCode generado por un record con return 42 (el mejor de 3 tras el calentamiento del JIT, OpenJDK 26, M1 Pro):
n= 1,000 record hashCode: 0.21 ms constant hashCode: 2.3 ms
n= 5,000 record hashCode: 0.17 ms constant hashCode: 61.9 ms
n=20,000 record hashCode: 1.26 ms constant hashCode: 1246.7 ms
Tres ejecuciones coincidieron con una diferencia de alrededor del 4% en los números grandes (de 1,201 a 1,247 ms). Cuatro veces más claves tardaron unas 20 veces más, porque cada búsqueda recorre el bucket compartido. Las filas del record son tan pequeñas que domina el ruido del JIT (5,000 salió más rápido que 1,000); el programa completo, HashCost.java, es solo HashSet.add y contains en dos bucles.
Records: clases de datos con el contrato incluido
Un record declara sus componentes una sola vez, y el compilador genera los campos private final, el constructor, los accessors (x(), no getX()), equals, hashCode y toString, todos coherentes entre sí.
import java.util.*;
public class Records {
record Point(int x, int y) {}
record Range(int lo, int hi) {
Range { // compact constructor
if (lo > hi) throw new IllegalArgumentException("lo > hi: " + lo + " > " + hi);
}
int length() { return hi - lo; }
}
record Tags(List<String> values) {
Tags { values = List.copyOf(values); } // defensive copy
}
public static void main(String[] args) {
Point a = new Point(1, 2), b = new Point(1, 2);
System.out.println(a);
System.out.println("equals=" + a.equals(b) + ", sameHash=" + (a.hashCode() == b.hashCode())
+ ", == " + (a == b));
System.out.println("HashSet size=" + new HashSet<>(List.of(a, new Point(3, 4))).size()
+ ", contains(1,2)=" + new HashSet<>(List.of(a)).contains(new Point(1, 2)));
System.out.println("x()=" + a.x() + ", length=" + new Range(3, 10).length());
var src = new ArrayList<>(List.of("java"));
Tags t = new Tags(src);
src.add("oops");
System.out.println(t);
try { t.values().add("x"); }
catch (UnsupportedOperationException e) { System.out.println("values().add -> " + e); }
new Range(10, 3);
}
}
Point[x=1, y=2]
equals=true, sameHash=true, == false
HashSet size=2, contains(1,2)=true
x()=1, length=7
Tags[values=[java]]
values().add -> java.lang.UnsupportedOperationException
Exception in thread "main" java.lang.IllegalArgumentException: lo > hi: 10 > 3
at Records$Range.<init>(Records.java:8)
at Records.main(Records.java:32)
- El constructor compacto (
Range { … }sin lista de parámetros) se ejecuta antes de asignar los campos. Es el lugar para validar y normalizar; puedes reasignar el parámetro (values = List.copyOf(values)), pero nothis.values. - Un record es inmutable solo en la superficie (shallow). Sin el
List.copyOf, elsrc.add("oops")posterior de quien llama se habría filtrado dentro del record. Copiar hace que el record sea seguro como clave de un mapa. - Los records no pueden tener campos de instancia extra: agregar
int z;dioerror: field declaration must be staticcon la pista(consider replacing field with record component). Asignar un componente dentro de un método dioerror: cannot assign a value to final variable x. - Los records no pueden extender una clase (extienden implícitamente
java.lang.Record), pero sí pueden implementar interfaces, que es justo en lo que se apoya el ejemplo sealed de más abajo.
Interfaces, métodos default y clases abstractas
Una interface describe lo que un tipo puede hacer. Desde Java 8 puede traer métodos default (comportamiento construido sobre los abstractos) y métodos de fábrica static, pero no estado de instancia. Una clase abstracta puede tener campos, constructores y métodos final, a cambio de ocupar el único lugar de superclase que tienes.
import java.util.*;
public class Kinds {
interface Notifier {
void send(String to, String msg); // abstract
default void sendAll(List<String> to, String msg) { // default
for (String t : to) send(t, msg);
}
static Notifier console() {
return (to, m) -> System.out.println("[console] " + to + ": " + m);
}
}
static abstract class Job {
private int runs; // state: an interface can't hold this
protected final String name;
Job(String name) { this.name = name; }
public final void run() { // template method
runs++;
System.out.println("start " + name + " #" + runs);
doWork();
}
protected abstract void doWork();
}
static class Cleanup extends Job {
Cleanup() { super("cleanup"); }
@Override protected void doWork() { System.out.println(" deleting temp files"); }
}
public static void main(String[] args) {
Notifier.console().sendAll(List.of("alice", "bob"), "deploy done");
Job j = new Cleanup();
j.run(); j.run();
}
}
[console] alice: deploy done
[console] bob: deploy done
start cleanup #1
deleting temp files
start cleanup #2
deleting temp files
Como Notifier tiene exactamente un método abstracto, una lambda puede implementarla. Job.run() es final, así que las subclases no pueden saltarse el contador; solo completan doWork().
Errores con los que te vas a topar:
Diamond.java:4: error: types A and B are incompatible;
static class C implements A, B { }
class C inherits unrelated defaults for hello() from types A and B
AbsNew.java:3: error: Half is not abstract and does not override abstract method doWork() in Job
AbsNew.java:4: error: Job is abstract; cannot be instantiated
El primero aparece cuando dos interfaces aportan el mismo método default. Sobrescríbelo y elige explícitamente con A.super.hello().
| Situación | Elige | Motivo |
|---|---|---|
| Datos inmutables identificados por sus valores (DTO, clave de mapa, resultado) | record |
equals/hashCode/toString generados y coherentes |
| Un conjunto cerrado de casos (método de pago, figura, resultado de una API) | sealed interface + records |
el compilador revisa que cada switch cubra todos los casos |
| Clases sin relación comparten una capacidad | interface (+ métodos default) |
una clase puede implementar muchas interfaces |
| Las subclases comparten campos, lógica de constructor o un algoritmo fijo | abstract class |
las interfaces no pueden guardar estado de instancia |
| Objeto mutable con invariantes (cuenta, carrito, conexión) | class normal, campos privados |
encapsulamiento; no es un record |
Interfaces sealed y switch con pattern matching
Una interface sealed enumera todas sus implementaciones. Así el compilador puede comprobar que un switch sea exhaustivo, y agregar un caso nuevo convierte cada switch que lo olvidó en un error de compilación en lugar de una sorpresa en producción.
public class Shapes {
sealed interface Shape permits Circle, Rect, Triangle {}
record Circle(double r) implements Shape {}
record Rect(double w, double h) implements Shape {}
record Triangle(double b, double h) implements Shape {}
static double area(Shape s) {
return switch (s) {
case Circle c -> Math.PI * c.r() * c.r();
case Rect(double w, double h) -> w * h; // record pattern
case Triangle t when t.b() == 0 -> 0; // guard
case Triangle t -> 0.5 * t.b() * t.h();
};
}
public static void main(String[] args) {
Shape[] all = { new Circle(1), new Rect(2, 3), new Triangle(4, 5) };
for (Shape s : all) System.out.printf("%-30s area=%.2f%n", s, area(s));
area(null);
}
}
Circle[r=1.0] area=3.14
Rect[w=2.0, h=3.0] area=6.00
Triangle[b=4.0, h=5.0] area=10.00
Exception in thread "main" java.lang.NullPointerException
at java.base/java.util.Objects.requireNonNull(Objects.java:220)
at Shapes.area(Shapes.java:8)
at Shapes.main(Shapes.java:19)
No hay rama default, y no hace falta. Borra los dos casos de Triangle y javac se detiene:
Shapes.java:8: error: the switch expression does not cover all possible input values
return switch (s) {
^
Esa es la gracia de sellar. Si hubieras escrito default -> 0, el triángulo faltante habría compilado y habría devuelto un área de 0 sin avisar. Agrega un tipo que no esté en permits y obtienes error: class is not allowed to extend sealed class: Shape (as it is not listed in its 'permits' clause).
Dos detalles de la ejecución: un switch con patrones lanza NullPointerException ante null a menos que agregues case null -> … (lo agregamos y el programa terminó con normalidad), y el orden de los casos importa: el Triangle t when … con guarda tiene que ir antes del Triangle t simple.
Comprobando los "desde Java N"
Compilamos los mismos archivos con valores de --release más antiguos en javac 26:
$ javac --release 15 Shapes17.java
error: sealed classes are not supported in -source 15
(use -source 17 or higher to enable sealed classes)
error: records are not supported in -source 15
(use -source 16 or higher to enable records)
$ javac --release 16 Shapes17.java
error: sealed classes are not supported in -source 16
(use -source 17 or higher to enable sealed classes)
$ javac --release 17 Shapes17.java && java -cp out Shapes17
Rect[w=2.0, h=3.0] 6.0
$ javac --release 17 Shapes.java
Shapes.java:9: error: patterns in switch statements are not supported in -source 17
(use -source 21 or higher to enable patterns in switch statements)
Shapes.java:10: error: deconstruction patterns are not supported in -source 17
(use -source 21 or higher to enable deconstruction patterns)
Shapes17.java es la misma jerarquía sealed con if (s instanceof Circle c) en lugar de un switch. Entonces: los records necesitan 16, los tipos sealed 17, y el switch con patrones y los record patterns 21. Si tu equipo está en Java 17, tienes la jerarquía sealed pero debes escribir la cadena de instanceof, y pierdes la comprobación de exhaustividad.
Límites honestos y notas de versión
- Todo el código se compiló y ejecutó con OpenJDK 26 (Temurin 26+35) en una Mac con Apple Silicon (M1 Pro). Las pruebas con
--releaseemulan niveles de lenguaje anteriores con javac 26; no instalamos JDK 16, 17 ni 21. - La medición del hash es un bucle con el mejor de 3 tras el calentamiento, no un benchmark con JMH. Úsala por la proporción (unas 1,000 veces con 20,000 claves), no por los números absolutos.
HashMapconvierte los buckets muy largos en árboles, lo cual ayuda solo cuando las claves sonComparable. Nuestra claveBadno lo era, así que vimos el peor caso.- El hash de identidad en
Account@6f3b5d16es distinto en cada ejecución.
Anterior: Curso de Java 1/6: tipos, strings e igualdad. Siguiente: Curso de Java 3/6: colecciones y su rendimiento. Relacionados: curso de Python 2, VB.NET 3: clases, herencia e interfaces (en inglés) y la versión de C# sobre interfaces (en inglés).
Preguntas frecuentes
¿Qué pasa si sobrescribo equals pero no hashCode en Java?
Dos objetos iguales reciben hash codes distintos, así que un HashSet guarda los dos y contains() devuelve false. En nuestra prueba, agregar el mismo punto dos veces produjo un set de tamaño 2 en 10,000 de 10,000 intentos, mientras que ArrayList.contains seguía devolviendo true. javac -Xlint:all avisa: [overrides] Class P1 overrides equals, but neither it nor any superclass overrides hashCode method.
¿Cuándo usar un record y cuándo una clase en Java?
Usa un record cuando el tipo es solo datos inmutables identificados por sus valores: genera el constructor, los accessors, equals, hashCode y toString, y puedes validar en un constructor compacto. Usa una clase cuando necesitas estado mutable, campos ocultos o heredar de otra clase. Los records se estandarizaron en Java 16; compilar con --release 15 falla.
¿Qué versión de Java necesito para sealed interfaces y switch con pattern matching?
Las clases e interfaces sealed necesitan Java 17. El pattern matching en switch y los patrones de deconstrucción de records necesitan Java 21: con --release 17, javac dijo que patterns in switch statements are not supported in -source 17 (use -source 21 or higher). Comprobamos ambos con javac 26.