Objetos, referencias e igualdad en Java

Una variable Java contiene un valor. La pregunta importante es si ese valor es un dato ordinario o una referencia que lleva a un objeto. La asignación copia ese valor en ambos casos.

Datos primitivos y referencias a objetos

Java tiene ocho tipos primitivos: byte, short, int, long, float, double, char y boolean. Una variable primitiva contiene sus datos directamente. Una variable de referencia contiene una referencia a un objeto o el valor especial null. Las clases como String, Scanner y ArrayList, tus propias clases y los arreglos son tipos de referencia.

En new Counter(), Java crea un objeto, ejecuta su constructor y produce una referencia. La asignación almacena esa referencia en c. Dibuja la variable como una caja con una flecha que lleva a un objeto separado. Cada evaluación de new crea un objeto distinto, aunque los argumentos coincidan.

Copia el valor y sigue el resultado

Con valores primitivos, cambiar la variable copiada deja intacta la primera variable:

int a = 5;
int b = a;
b = b + 1;

La última línea lee 5 de b, suma 1 y almacena 6 en b. El valor de a sigue siendo 5.

Para un ejemplo con referencias, utiliza esta clase pequeña:

class Counter {
    private int value;

    Counter() { this.value = 0; }
    Counter(int value) { this.value = value; }
    void increase() { value++; }
    int value() { return value; }
}

Ahora sigue estas sentencias:

Counter first = new Counter();
Counter second = first;
second.increase();
System.out.println(first.value()); // 1

Solo la primera línea crea un contador. La segunda copia la referencia, así que la llamada al método cambia el único contador al que llegan ambas variables. Para crear un contador independiente con los mismos datos, escribe new Counter(first.value()). Copiar una variable no llama a un constructor.

Envoltorios y cadenas inmutables

Cada tipo primitivo tiene una clase envoltorio, como Integer, Double, Boolean o Character. Las variables de tipo envoltorio contienen referencias o null. Java puede convertir automáticamente entre un valor primitivo y su envoltorio; estas conversiones son el empaquetado automático y el desempaquetado. Las listas contienen referencias, así que una lista de enteros es ArrayList<Integer>.

String también es un tipo de referencia, pero sus objetos son inmutables: sus caracteres no pueden cambiar después de su creación.

String s = "java";
String t = s;
t = t.toUpperCase();

Aquí s sigue haciendo referencia a «java» y t hace referencia a «JAVA». La última línea asigna el resultado a t; no cambia la cadena original compartida. Los métodos de String pueden reutilizar el objeto original cuando no hace falta cambiarlo.

Imprimir un objeto utiliza su método toString(). Sin una sobrescritura, el resultado heredado tiene una forma como Counter@7e9e5f8a: nombre de la clase, @ y un código hash hexadecimal. Define toString() cuando la salida impresa deba mostrar los datos del objeto.

Dos variables que hacen referencia al mismo objeto son alias. Un alias proporciona otra vía para acceder a datos existentes. Para seguir un programa, mantén separadas las variables de los objetos a los que llegan.

La mutación cambia datos; la reasignación cambia una variable

Una mutación cambia el estado de un objeto, como su peso almacenado. Una reasignación introduce un valor diferente en una variable. En una variable de referencia, eso cambia su flecha.

Utiliza una caja cuyo peso se expresa en kilogramos:

class Box {
    private double weight;
    Box(double weight) { this.weight = weight; }
    double getWeight() { return weight; }
    void setWeight(double weight) { this.weight = weight; }
}

Sigue esta secuencia:

Box a = new Box(2);
Box b = a;
b.setWeight(5);
b = new Box(7);

1. Dibuja la variable a apuntando al objeto A, con peso 2.
2. Dibuja b apuntando a ese mismo objeto A. Sigue habiendo una caja.
3. Cambia el peso dentro del objeto A a 5. Ambas vías llegan ahora al peso 5.
4. Crea el objeto B con peso 7 y redirige solo b hacia él.

Al final, a.getWeight() es 5 y b.getWeight() es 7. La cuarta sentencia no restablece el objeto A ni mueve a al objeto B.

La alcanzabilidad determina el tiempo de vida de un objeto

Un objeto es alcanzable mientras el programa en ejecución pueda seguir alguna cadena de referencias utilizable hasta él. Esa cadena puede pasar por una variable, un campo de objeto o un elemento de lista. Por tanto, que desaparezca una variable local no basta para que un objeto sea inalcanzable si una lista todavía lo contiene.

Continúa el seguimiento con a = null;. En este ejemplo, el objeto A, que pesa 5 kg, ya no tiene ninguna vía alcanzable. Queda disponible para la recolección de basura. Java recupera automáticamente la memoria de los objetos inalcanzables, pero el recolector decide cuándo; la asignación no garantiza una recolección inmediata. El objeto B sigue siendo alcanzable a través de b.

No liberas objetos Java manualmente. Cuando un programa pierde su última referencia utilizable a un objeto, también pierde la capacidad de inspeccionar o cambiar los datos de ese objeto.

Encuentra los alias ocultos

Los alias aparecen cuando se añade un objeto a una lista, se pasa a un método, se devuelve desde un método o se almacena en el campo de otro objeto. Cada operación puede transmitir una referencia. Antes de mutar un objeto recibido de otro lugar, identifica qué otro código todavía puede llegar a él.

Un error habitual empieza con la idea: «He copiado la variable, así que tengo mi propia caja». Utiliza un objeto nuevo cuando los cambios deban ser independientes. Para diagnosticar el error, cuenta las creaciones de objetos por separado de las asignaciones, etiqueta cada objeto una sola vez y procesa cada sentencia en orden. No vuelvas a dibujar un objeto solo porque una segunda variable apunte ahora a él.

El valor null significa que una referencia no lleva a ningún objeto. Es útil para indicar un resultado ausente, pero un programa debe manejar esa ausencia antes de intentar utilizar un objeto.

Ausente no es lo mismo que vacío

String text = ""; hace referencia a una cadena real de longitud 0. String text = null; no hace referencia a ninguna cadena, así que no hay ningún objeto sobre el que llamar a length().

Un valor primitivo no puede contener null: int x = null; no se compila. Un envoltorio sí puede contenerlo: Integer x = null; se compila. Convertir ese envoltorio a un valor primitivo con int y = x; lanza una NullPointerException, porque el desempaquetado necesita un objeto envoltorio.

Los campos reciben valores iniciales predeterminados cuando se crea un objeto. Los campos de referencia empiezan con null, los campos numéricos con 0 y los campos booleanos con false, hasta que la inicialización les asigna otros valores. Las variables locales no tienen valor predeterminado. Leer una variable local antes de asignarle un valor causa un error de compilación, como «es posible que la variable no se haya inicializado».

Encuentra la referencia ausente

Llamar a un método de instancia a través de null, acceder a un campo de instancia a través de él o leer la longitud de un arreglo a través de él lanza NullPointerException en tiempo de ejecución. Por ejemplo:

String name = null;
System.out.println(name.length());

Lee el número de línea de la excepción y después identifica qué referencia faltaba en esa línea. Los mensajes informativos están activados de forma predeterminada desde Java 15. Un mensaje puede indicar Cannot invoke "SimpleDate.getYear()" because "this.birthday" is null. Los nombres locales pueden aparecer como marcadores como <local4>, según los detalles de compilación. Sigue el rastro hasta el constructor, la asignación o la búsqueda que debería haber proporcionado el objeto.

Imprimir una variable String cuyo valor es null imprime «null»; concatenarla produce texto como «Hi null». Estas operaciones no necesitan llamar a un método de instancia a través de esa variable. Pueden revelar datos ausentes antes de que falle una llamada posterior a un método.

Comprueba antes de usar

El operador && utiliza evaluación en cortocircuito: evalúa el lado derecho solo si el izquierdo es verdadero.

if (name != null && name.length() > 0) {
    System.out.println(name);
}

Cuando name es null, la primera comprobación es falsa y se omite length(). Al invertir las dos comprobaciones se pierde esa protección: la llamada al método se ejecutaría primero.

La cadena fija es un objeto conocido, así que su equals puede recibir null y devolver false. command.equals("quit") falla cuando command es null. Del mismo modo, x.equals(null) no sirve para comprobar si x existe: ya requiere un objeto.

Haz que la ausencia sea una decisión de diseño clara

Inicializa un campo de lista con new ArrayList<>() para que una colección vacía esté disponible de inmediato. Si una búsqueda devuelve null para indicar «no encontrado», documenta ese resultado y compruébalo en el lugar de la llamada. Evita llenar todos los campos con objetos arbitrarios solo para silenciar una excepción: proporciona el objeto que necesita el programa o da a la ausencia un significado claro que el código que llama pueda manejar.

Java pasa todos los argumentos por valor. Un parámetro es una variable nueva que recibe una copia del valor del argumento. Para un argumento que es un objeto, el valor copiado es una referencia.

¿Cambiar el parámetro o cambiar el objeto?

Un parámetro primitivo tiene sus propios datos:

static void addTen(int n) {
    n = n + 10;
}

Si x es 5, llamar a addTen(x) deja x en 5. Solo el parámetro local n pasa a ser 15.

Un parámetro de referencia puede llegar al mismo objeto que quien llama. Supón que Person.growOlder() aumenta la edad almacenada:

static void celebrate(Person p) {
    p.growOlder();
}

static void replace(Person p) {
    p = new Person("Bo", 30);
}

Durante celebrate(ana), el parámetro p y la variable ana son alias. La edad modificada sigue siendo visible después. Durante replace(ana), asignar un valor a p solo redirige ese parámetro. La variable ana de quien llama sigue haciendo referencia a la persona original. Un método que intercambia dos parámetros de referencia tiene la misma limitación: intercambia sus propias copias, no las variables de quien llama.

Recibe un objeto de otra clase

Un control puede leer la altura de una persona y mantener su propio recuento de comprobaciones. Esta clase espera una persona no nula con un método getHeight() que devuelve centímetros:

class HeightGate {
    private int minHeight;
    private int checks;

    HeightGate(int minHeight) {
        this.minHeight = minHeight;
    }

    boolean allowIn(Person p) {
        checks++;
        return p.getHeight() >= minHeight;
    }

    int checks() { return checks; }
}

Para un control configurado en 120 cm, comprobar personas de 132 cm y 115 cm devuelve verdadero y falso. Después, el control registra 2 comprobaciones. Lee la altura de la persona mediante un método público y cambia su propio contador.

Recibe otro objeto de la misma clase

Dentro de SimpleDate.before(SimpleDate other), this es la fecha que recibe la llamada y other es el argumento. Una clase puede leer los campos privados de cualquier objeto de esa misma clase.

Para los campos day, month y year, compara en orden:

boolean before(SimpleDate other) {
    if (year != other.year) {
        return year < other.year;
    }
    if (month != other.month) {
        return month < other.month;
    }
    return day < other.day;
}

Para el 14 de marzo de 2001 y el 2 de noviembre de 2001, los años coinciden y el mes 3 es menor que el mes 11, así que la primera fecha es anterior. Las fechas iguales devuelven falso porque ninguna es anterior a la otra.

Person.olderThan(other) puede delegar en birthday.before(other.birthday). La comparación de fechas corresponde a los datos de fecha. Los métodos que llaman a métodos de instancia sobre un parámetro necesitan un argumento no nulo; compruébalo o incluye ese requisito en la documentación de uso del método.

Un método que devuelve un objeto devuelve una referencia. Su tipo indica qué clase de objeto puede devolverse, pero no indica si el objeto es nuevo, compartido o si está ausente. El propósito del método debe dejar clara esa decisión.

Crea un resultado

Un método de fábrica proporciona un objeto. Puede crear uno o reutilizar uno existente. Aquí cada llamada crea deliberadamente un boleto distinto:

class TicketMachine {
    private int nextNumber = 1;

    Ticket issue() {
        Ticket t = new Ticket(nextNumber);
        nextNumber++;
        return t;
    }
}

La máquina espera un constructor de Ticket que almacene su número. Tres llamadas crean tres boletos numerados 1, 2 y 3. Devolver una variable local es seguro: su referencia se copia a quien llama, que puede mantener el objeto alcanzable después de que la variable local salga de ámbito.

Un método de copia promete un objeto independiente. En la clase Counter:

Counter copy() {
    return new Counter(this.value);
}

Después de Counter a = new Counter(4); Counter b = a.copy(); b.increase();, a.value() es 4 y b.value() es 5. Sustituir a.copy() por a compartiría el contador.

Un método también puede crear un objeto calculado. Para un Point con campos double x e y:

Point midpoint(Point other) {
    return new Point((x + other.x) / 2.0,
                     (y + other.y) / 2.0);
}

Los puntos (2, 4) y (6, 10) dan (4,0; 7,0). El método calcula cada coordenada y pasa ambas a un punto nuevo; ninguno de los puntos originales cambia.

Devuelve un objeto ya almacenado

El método findByName de un registro debe devolver la persona almacenada que coincida si quienes llaman necesitan trabajar con esa entrada. Crear new Person(name, 0) devolvería datos de sustitución inventados y desvincularía del registro los cambios posteriores.

Una búsqueda puede devolver null cuando no existe ninguna coincidencia:

Person p = register.findByName("Lin");
if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Not found");
}

Si p es la persona almacenada, los cambios realizados a través de p también cambian la persona a la que se accede mediante el registro. Una sentencia return no copia el objeto.

Mantén bajo control el estado interno mutable

Supón que Person.getBirthday() devuelve su campo SimpleDate y que esa fecha tiene métodos modificadores. Quien llama puede entonces cambiar la fecha de nacimiento de la persona sin llamar a un método de Person. Esto es una exposición del estado mutable.

Para proteger el campo, devuelve una fecha nueva construida a partir de sus valores:

SimpleDate getBirthday() {
    return new SimpleDate(birthday.getDay(),
                          birthday.getMonth(),
                          birthday.getYear());
}

Esta versión requiere que se haya inicializado un objeto de fecha de nacimiento. Otros diseños utilizan una fecha inmutable u ofrecen consultas específicas sin un método de acceso a la fecha. Elige el comportamiento de cada método: find normalmente comparte una entrada almacenada, mientras que copy crea independencia. El nombre breve de un método de acceso, por sí solo, no garantiza protección.

La composición construye una clase utilizando campos cuyos tipos son otras clases. Expresa una relación de «tener»: una persona tiene una fecha de nacimiento; un curso tiene un profesor. El objeto externo almacena una referencia al objeto contenido.

Crea y conecta los objetos

Un constructor puede recibir una fecha existente:

class Person {
    private String name;
    private SimpleDate birthday;

    Person(String name, SimpleDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    boolean olderThan(Person other) {
        return birthday.before(other.birthday);
    }

    public String toString() {
        return name + ", born " + birthday;
    }
}

La llamada new Person("Ana", new SimpleDate(14, 3, 2001)) crea primero una fecha y después da su referencia a la persona. Otra posibilidad es que un constructor de persona reciba el día, el mes y el año y cree la fecha dentro de su cuerpo. Con ese enfoque, quien llama no conserva una referencia a esa fecha recién creada.

Delega trabajo en el objeto contenido

La llamada birthday.before(other.birthday) pide al objeto de fecha que compare fechas. Person no necesita repetir las comparaciones de año, mes y día. La concatenación en toString() también delega: Java llama al toString() del objeto de fecha de nacimiento para obtener su texto.

Un objeto de fecha puede ayudar a calcular la edad. Empieza por el año actual menos el año de nacimiento. Después forma la fecha del cumpleaños de este año y resta uno si la fecha actual es anterior. Una persona nacida el 14 de marzo de 2001 tiene 24 años el 1 de enero de 2026: la diferencia de años es 25, pero el cumpleaños todavía no ha llegado. El 14 de marzo de 2026, el cumpleaños ya ha llegado y la edad es 25. Mantener la comparación de fechas en SimpleDate evita reproducir sus reglas en cada método de persona.

Decide si se comparte el objeto interno

El constructor anterior almacena su argumento directamente. Si dos personas reciben un mismo SimpleDate mutable, ambos campos de fecha de nacimiento apuntan a la misma fecha. Cambiar esa fecha afecta a ambas personas.

Un constructor defensivo puede copiar el día, el mes y el año de la fecha recibida. Una fecha inmutable no tiene métodos que cambien su estado y mantiene fijos sus valores; los campos primitivos simples pueden ser final. Copiar al recibir la fecha importa incluso si un método de acceso devuelve después una copia, porque quien llamó originalmente todavía puede conservar el objeto recibido.

Maneja las conexiones opcionales

Un Course podría no tener profesor todavía. Si ese es un estado con sentido, teacherName() puede comprobar el campo y devolver «todavía no hay profesor». De lo contrario, exige un profesor en el momento de la construcción.

En course.getTeacher().getName(), cada llamada de instancia necesita un objeto: un curso nulo falla en getTeacher() y un profesor nulo falla en getName(). Un método en el curso puede mantener esa comprobación de ausencia en un solo lugar y evitar que cada llamada necesite conocer la misma cadena.

Un ArrayList<Person> es un objeto cuyos elementos contienen referencias a personas. La lista controla su secuencia de entradas; cada persona controla sus propios campos. Son tipos de cambio distintos.

Añade un objeto y vuelve a acceder a él

ArrayList<Person> people = new ArrayList<>();
people.add(ana);
people.get(0).growOlder();

Este código necesita import java.util.ArrayList; y una persona ana existente y no nula. add copia la referencia. La llamada a growOlder() llega a la misma persona que ana, así que el cambio de edad es visible por ambas vías. La lista nunca crea aquí una segunda persona.

Puedes crear un objeto al añadirlo: people.add(new Person("Lin", 1998));, utilizando un constructor de persona que acepte un nombre y un año de nacimiento. La lista proporciona entonces al programa una vía para acceder a esa nueva persona mediante get o un bucle. Los argumentos de tipo de las listas deben ser tipos de referencia, así que utiliza ArrayList<Integer> para números enteros.

Calcula a partir de objetos y selecciona un objeto

Supón que una lista contiene paquetes con pesos de 2,5 kg, 4,0 kg y 1,5 kg. Un bucle suma el peso de cada paquete:

double total = 0;
for (Parcel p : parcels) {
    total += p.getWeight();
}

Las sumas acumuladas son 2,5, 6,5 y 8,0 kg. Seleccionar el paquete más pesado necesita una referencia además de una comparación:

Parcel heaviest = parcels.get(0);
for (Parcel p : parcels) {
    if (p.getWeight() > heaviest.getWeight()) {
        heaviest = p;
    }
}

Esta selección espera una lista no vacía. El resultado es el objeto del paquete de 4,0 kg, así que quien llama también puede utilizar sus otros métodos. Para una lista vacía, decide cómo indicar la ausencia de resultado antes de leer el elemento 0.

Busca en todas las entradas

Una búsqueda por nombre en una clase que almacena people puede utilizar:

Person findByName(String name) {
    for (Person p : people) {
        if (p.getName().equals(name)) {
            return p;
        }
    }
    return null;
}

Esta versión espera personas no nulas con nombres no nulos. La primera coincidencia se devuelve de inmediato. El return null final va después del bucle: una comparación fallida con la primera persona no descarta coincidencias posteriores.

contains, indexOf y remove(Object) buscan utilizando equals. Si Person hereda una igualdad basada en la identidad, una persona recién creada no coincidirá con una existente solo porque coincidan sus campos.

Elimina la pertenencia sin destruir un objeto

Un objeto puede aparecer dos veces en una lista o en varias listas. Eliminar una entrada no destruye el objeto ni elimina otras referencias a él.

No elimines entradas directamente de una lista mientras la recorres con for-each. Puede provocar ConcurrentModificationException. Recopila primero los candidatos y después elimínalos:

ArrayList<Person> toRemove = new ArrayList<>();
for (Person p : people) {
    if (p.getName().equals("Lin")) {
        toRemove.add(p);
    }
}
people.removeAll(toRemove);

El recorrido termina antes de que cambien los elementos de la lista. removeAll utiliza la igualdad, así que elimina las entradas iguales a los candidatos recopilados.

Una clase puede mantener una lista en un campo privado y ofrecer operaciones que describan su propósito. Una lista de reproducción almacena canciones, las cuenta y calcula su duración. Quienes llaman no deberían tener que gestionar su lista directamente.

Inicializa y encapsula la colección

Esta lista de reproducción espera objetos Song no nulos con un método seconds():

import java.util.ArrayList;

class Playlist {
    private String name;
    private ArrayList<Song> songs;

    Playlist(String name) {
        this.name = name;
        this.songs = new ArrayList<>();
    }

    void add(Song song) { songs.add(song); }
    int count() { return songs.size(); }

    int totalSeconds() {
        int total = 0;
        for (Song song : songs) {
            total += song.seconds();
        }
        return total;
    }
}

Sin new ArrayList<>(), el campo de referencia sigue siendo null; la primera llamada a add falla entonces. Una lista vacía ya es un objeto utilizable, con tamaño 0.

Para canciones que duran 210 s, 185 s y 247 s, count() devuelve 3. El total aumenta de 210 a 395 y después a 642 s. La división entera entre 60 da 10 minutos, con un resto de 42 segundos. Un método longest() puede seleccionar y devolver la canción de 247 s, utilizando el mismo patrón de selección de referencias que para el paquete más pesado. Define un resultado para la ausencia de canciones en una lista de reproducción vacía.

Protege la pertenencia mediante métodos

Mantener songs como privado bloquea el acceso directo al campo, pero return songs; expone esa misma lista. Quien llama podría llamar a clear() y eludir todas las reglas de la lista de reproducción.

Las operaciones específicas como add, count y totalSeconds mantienen la responsabilidad en la lista de reproducción. Su método add podría imponer un tamaño máximo o rechazar duplicados con songs.contains(song). Las comprobaciones de duplicados basadas en el contenido necesitan que equals de la clase de canción defina qué campos hacen que dos canciones sean iguales.

Cuando un constructor recibe una lista inicial, copia su estructura con this.songs = new ArrayList<>(initialSongs);. Almacenar el parámetro directamente permitiría que quien llama conserve un alias de la lista interna de la lista de reproducción.

Una lista nueva puede seguir compartiendo canciones

Una consulta puede devolver new ArrayList<>(songs). Esta es una copia superficial: un objeto de lista nuevo que contiene las referencias a las canciones existentes.

Una consulta songsLongerThan(200) crea una lista de resultados nueva, recorre las canciones almacenadas y añade las que duran más de 200 s. Para las tres canciones anteriores devuelve las de 210 s y 247 s. Cuando los valores de las canciones también deban ser independientes, copia las canciones mutables o haz que Song sea inmutable.

La identidad pregunta si dos referencias llevan al mismo objeto. La igualdad de contenido pregunta si los objetos tienen los mismos datos relevantes, según las reglas de la clase. Dos objetos de libro distintos pueden describir el mismo título y año de publicación sin ser idénticos.

Elige la comparación adecuada

Toda clase hereda equals(Object) de Object. Esa versión predeterminada comprueba la identidad. Java no inspecciona automáticamente todos los campos de una clase nueva.

String a = "java";
String b = new String("java");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

new String crea un objeto distinto, mientras que String.equals compara sus caracteres. La comparación de texto distingue mayúsculas y minúsculas: "Java".equals("java") es falso. equalsIgnoreCase proporciona una comparación que no las distingue cuando esa es la regla buscada.

Por qué a veces parece que la identidad compara el contenido

Los literales de cadena iguales comparten un objeto de cadena, así que "java" == "java" es verdadero. Esto puede ocultar un error en una prueba pequeña. El texto obtenido de la entrada o construido mientras se ejecuta un programa no tiene por qué compartir ese objeto. Utiliza equals para comparar el contenido independientemente de cómo se haya obtenido el texto.

Las comparaciones de envoltorios tienen una trampa similar:

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c.equals(d)); // true

El empaquetado automático reutiliza objetos Integer para los valores de −128 a 127. Que valores mayores compartan o no un objeto no es una regla de comparación numérica portable. En una configuración estándar, los dos envoltorios de 1000 son distintos, pero se permite una caché mayor. Utiliza equals de los envoltorios para comparar sus valores o compara valores primitivos. Si un lado de == es un int, Java desempaqueta el envoltorio y compara valores numéricos; desempaquetar un envoltorio nulo falla.

Decide qué campos definen la igualdad

Para un catálogo de libros, el título y el año de publicación podrían definir la igualdad, mientras que se ignora la persona que tiene el libro prestado en ese momento. Esos campos seleccionados deben determinar el método de igualdad. Otro programa podría elegir en su lugar un identificador único; la regla útil depende de lo que representen sus objetos.

Un ArrayList utiliza equals en contains, indexOf y remove(Object). Supón que Book solo almacena campos y hereda equals. Añadir un new Book("Dune", 1965) no hace que contains(new Book("Dune", 1965)) sea verdadero: la segunda expresión crea un objeto diferente. Sobrescribir la igualdad por título y año permite que una búsqueda encuentre ese contenido igual.

HashSet y HashMap también utilizan hashCode para reducir el número de objetos candidatos antes de comprobar la igualdad. Por tanto, definir una igualdad de contenido también requiere una regla de código hash coherente.

Un método de igualdad debe reemplazar el equals(Object) heredado y comparar los campos que definen el significado de tu objeto. La firma correcta importa tanto como las comparaciones que contiene.

Un patrón completo de igualdad

Esta clase utiliza el título y el año, permite un título nulo y mantiene fijos sus campos de igualdad:

import java.util.Objects;

final class Book {
    private final String title;
    private final int year;

    Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Book)) {
            return false;
        }
        Book book = (Book) other;
        return year == book.year
            && Objects.equals(title, book.title);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, year);
    }
}

Lee equals en cuatro pasos. La comprobación de identidad acepta el mismo objeto de inmediato. La comprobación de tipo rechaza todo lo que no sea un libro, incluido null. La conversión explícita proporciona una variable Book mediante la cual se pueden leer los campos. La expresión final comprueba ambos campos de igualdad.

El tipo del parámetro es Object, no Book. Escribir equals(Book other) sobrecarga el nombre con otro método y deja sin cambios el equals(Object) heredado. Una llamada directa puede parecer que funciona mientras ArrayList.contains sigue utilizando la identidad. @Override hace que el compilador detecte ese error de firma.

Desde Java 16, la comprobación de tipo y la conversión explícita se pueden combinar: if (!(other instanceof Book book)) { return false; }. Una vez superada la comprobación, book está disponible para comparar los campos.

Adapta las comparaciones a los tipos de campo

Utiliza == para campos enteros, de carácter y booleanos. Utiliza el equals de un objeto para comparar su contenido. Para un campo de objeto que puede ser nulo, Objects.equals(a, b) devuelve verdadero cuando ambos son null, falso cuando solo uno es null y, en los demás casos, utiliza la igualdad.

Para campos double, Double.compare(x, other.x) == 0 proporciona un tratamiento coherente de los valores especiales: dos valores NaN se comparan como iguales y se distingue entre cero positivo y negativo. Acompaña esa elección de una regla hash compatible. El operador == aplicado directamente a valores en coma flotante trata NaN de otra manera.

Comprueba el contrato de igualdad

Para referencias no nulas, la igualdad debe ser:

• Reflexiva: x.equals(x) es verdadero.
• Simétrica: x.equals(y) y y.equals(x) coinciden.
• Transitiva: si x es igual a y e y es igual a z, x es igual a z.
• Consistente: las llamadas repetidas coinciden mientras los datos comparados no cambien.
• Falsa para null: x.equals(null) es falso.

Dos libros de «Dune», 1965, se comparan como iguales; cambiar uno de los años a 1984 hace que sean distintos. Un libro no debe compararse como igual a una cadena que contiene su título: la cadena rechazaría el libro y rompería la simetría.

Algunas implementaciones utilizan other == null || getClass() != other.getClass() para comprobar el tipo. Esta expresión rechaza clases en tiempo de ejecución diferentes. instanceof puede aceptar subclases; para la clase final anterior no existe ninguna subclase y ambas comprobaciones coinciden.

Un código hash es un número entero que se utiliza para reducir el ámbito de una búsqueda. HashSet y HashMap lo utilizan para encontrar objetos candidatos y después utilizan equals para confirmar una coincidencia. No es un identificador único de objeto.

El contrato funciona en un solo sentido

Los objetos iguales deben devolver el mismo código hash. Los objetos distintos también pueden compartir un código; eso es una colisión. Una colisión no los hace iguales, porque la igualdad se sigue comprobando.

Un código hash debe mantenerse consistente mientras la información utilizada por equals no cambie. En una implementación correcta, códigos hash diferentes descartan la igualdad, pero códigos hash iguales no la establecen.

Cuando una clase sobrescribe equals pero hereda Object.hashCode, los objetos separados que son iguales suelen recibir códigos diferentes. Entonces un conjunto puede conservar ambos y una búsqueda en un mapa con una clave nueva pero igual puede fallar. El fallo exacto no está garantizado, porque los códigos heredados de objetos diferentes pueden coincidir. Corrige el contrato en lugar de depender de un fallo concreto de búsqueda.

Calcula a partir de los campos de igualdad

Para la clase de libro que compara el título y el año:

@Override
public int hashCode() {
    return Objects.hash(title, year);
}

Importa java.util.Objects. Los mismos valores de campo producen ahora el mismo resultado. Un conjunto de libros almacena una entrada después de añadir dos libros iguales, y un mapa puede recuperar un valor utilizando como clave un libro nuevo pero igual.

Objects.hash combina los códigos hash de los campos utilizando 31. Para «Dune», el código hash de la cadena es 2 141 736. Al combinar ese título y el año 1965 se multiplica 31 por la suma de 31 y 2 141 736, y después se suma 1965: el resultado es 66 396 742.

El cálculo del hash de una cadena también utiliza 31. Para «ab», los códigos de carácter 97 y 98 dan 97 multiplicado por 31 más 98, es decir, 3105. Los cálculos más largos pueden superar el rango de int y desbordarse, así que un código hash negativo es normal.

No cambies la clave mientras esté almacenada

Supón que el año de un libro es mutable y afecta a su código hash. Después de insertarlo en un conjunto, cambiar el año puede hacer que contains(book) falle incluso con esa misma referencia: la búsqueda utiliza ahora un código diferente. El conjunto puede seguir indicando un tamaño de 1.

Mantén estables los campos de igualdad mientras un objeto sea un elemento de un conjunto o una clave de un mapa. Si deben cambiar, elimina el objeto mientras todavía se apliquen sus valores antiguos, cámbialo y vuelve a insertarlo. Intentar eliminarlo solo después del cambio puede provocar el mismo problema de búsqueda.

La igualdad generada sigue necesitando una buena elección de datos

Java 16 y posteriores admiten registros, como record Book(String title, int year) {}. Un registro genera los métodos de acceso title() y year(), además de la igualdad, el cálculo del hash y una representación textual legible a partir de todos sus componentes. Los campos de los componentes son final. Este ejemplo es un valor inmutable útil porque sus componentes son una cadena y un entero; un registro que contenga una lista mutable seguiría compartiendo el estado de esa lista.

Para las clases ordinarias, un IDE puede generar equals y hashCode conjuntamente. Selecciona los campos que definen la igualdad deseada y mantén ambos métodos coherentes cuando cambie esa elección.

La interfaz de usuario lee la entrada y muestra la salida. La lógica del programa almacena datos y aplica reglas. Un diseño separado pasa valores a la lógica y recibe resultados; sus clases de lógica no utilizan Scanner ni System.out.

Conecta los objetos en main

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    TemperatureLog log = new TemperatureLog();
    UserInterface ui = new UserInterface(scanner, log);
    ui.start();
}

Con import java.util.Scanner;, esta conexión crea un lector de entrada, un registro y una interfaz. Se coloca dentro de la clase de entrada del programa. UserInterface almacena los objetos proporcionados en campos para que todos los comandos trabajen con el mismo registro.

Devuelve valores que cualquier llamada pueda utilizar

Un registro podría proporcionar add(double celsius), count(), average() y max(). Las lecturas de 18,5, 21,0 y 19,5 °C tienen una suma de 59,0, un recuento de 3, un máximo de 21,0 y una media de aproximadamente 19,6667 °C. La interfaz de usuario puede redondear la media devuelta con Math.round(average * 10) / 10.0 y mostrar 19,7 °C.

Devolver el número facilita las comprobaciones directas. Un método llamado printAverage() que solo imprime vincula un cálculo a la salida por consola, lo que dificulta su reutilización.

Para un bucle de comandos sencillo, supón que add acepta temperaturas válidas y que count devuelve su número:

class UserInterface {
    private Scanner scanner;
    private TemperatureLog log;

    UserInterface(Scanner scanner, TemperatureLog log) {
        this.scanner = scanner;
        this.log = log;
    }

    void start() {
        while (true) {
            String command = scanner.nextLine();
            if ("quit".equals(command)) {
                break;
            }
            if ("count".equals(command)) {
                System.out.println(log.count());
            }
        }
    }
}

El bucle maneja la interacción. Pide un resultado al registro y lo imprime sin saber cómo se almacenan las lecturas. Un comando de media debe manejar un registro vacío según el resultado documentado de la lógica o comprobar count() antes de llamar a un método que requiere lecturas.

Valida en el límite adecuado

La lógica puede hacer que add devuelva falso sin almacenar una lectura inferior a −273,15 °C. Así, todas las llamadas reciben la misma regla de datos. La interfaz de usuario decide cómo comunicar ese rechazo y volver a preguntar. Convertir una entrada no numérica en un mensaje de error útil también es tarea de la interfaz.

Utiliza un Scanner para System.in y pásalo a quienes lean entrada. Varios escáneres pueden competir por la entrada almacenada en búfer, y cerrar uno cierra el flujo de entrada subyacente. Mantén el tiempo de vida del escáner compartido bajo el control del código propietario de la entrada del programa.

Más adelante, la lógica puede admitir otra interfaz mediante los mismos métodos públicos. La reutilización surge de mantener los cálculos y las reglas de validez disponibles como resultados de métodos, independientemente de un bucle de comandos concreto.

Un programa separado puede crecer mediante pequeños cambios sucesivos. Proporciona a la lógica un método útil, compruébalo directamente y después conecta un comando que recoja su entrada y muestre su resultado.

Añade una consulta a la lógica

Un TemperatureLog que almacena un ArrayList<Double> readings inicializado puede contar las lecturas superiores a un límite:

int countAbove(double limit) {
    int count = 0;
    for (double reading : readings) {
        if (reading > limit) {
            count++;
        }
    }
    return count;
}

La comparación estricta excluye las lecturas exactamente iguales al límite. Para 18,5, 21,0, 19,5 y 23,0 °C, countAbove(20.0) devuelve 2. Coloca la comparación en el registro para que todas las llamadas obtengan la misma regla.

El comando de la interfaz lee un límite, llama a log.countAbove(limit) e imprime el recuento. Si cada comando se vuelve largo, divide start() en métodos auxiliares privados como addReading() y showStatistics(). Los métodos auxiliares organizan la interacción; no trasladan las reglas de datos fuera del registro.

Comprueba sin escribir comandos

Crea el objeto de lógica y llama a sus métodos con valores cuyas respuestas conozcas:

TemperatureLog log = new TemperatureLog();
log.add(18.5);
log.add(21.0);
log.add(19.5);
log.add(23.0);
System.out.println(log.count() == 4);
System.out.println(log.average() == 20.5);
System.out.println(log.max() == 23.0);
System.out.println(log.countAbove(20.0) == 2);

La suma es 82,0, así que la media esperada es 20,5. Estos valores concretos tienen representaciones binarias exactas, lo que hace que estas comprobaciones directas de igualdad sean adecuadas para el ejemplo. Comprueba también un registro vacío según su comportamiento documentado, un límite que coincida con una lectura y el rechazo de una entrada no válida sin cambiar el recuento. Las herramientas de pruebas automatizadas se basan en la misma idea de una entrada conocida y un resultado esperado.

Cambia el almacenamiento solo si sigue admitiendo las consultas

Una interfaz que solo llama a average, count y max no necesita saber si el registro contiene una lista. Los campos de suma acumulada, recuento y máximo pueden responder a esas tres consultas sin conservar todas las lecturas.

Una consulta countAbove(limit) con cualquier límite necesita más información. Las muestras 18, 22, 23 y 20, 20, 23 tienen la misma suma 63, el mismo recuento 3 y el mismo máximo 23, pero sus recuentos por encima de 20 son 2 y 1. Conservar solo esos tres valores agregados hace perder la distinción. Los métodos públicos describen qué debe seguir funcionando después de un cambio de almacenamiento.

Combina las ideas de diseño

Un recetario puede ser propietario de una lista privada de recetas. Cada receta puede contener ingredientes medidos en gramos y un tiempo de cocción en minutos. La igualdad puede permitir comprobar duplicados, mientras una interfaz añade, enumera y busca recetas mediante los métodos del recetario. Una lista de resultados copiada puede proteger la pertenencia y seguir compartiendo objetos de receta; decide si quienes llaman pueden cambiar esas recetas.

Trabaja en pasos pequeños: implementa un método, compruébalo y después añade su comando. Si un cambio estropea un resultado existente, vuelve a un estado funcional y aísla ese cambio antes de añadir otra función.