uno21 compromiso con su necesidad

Igualdad de objetos en Java (II)

Siguiendo con la nota de unos días atrás, Igualdad de objetos en Java (I), vamos a mostrar cómo debería codificarse un método equals para que funcione de la manera apropiada. En un futuro artículo veremos los fundamentos matemáticos de la igualdad, pero por el momento nos interesa ensuciarnos las manos en el código.
Recordemos la firma del método:

public boolean equals(Object obj);

Por lo tanto, la llamada al mismo tendrá la forma:

unObjeto.equals(otroObjeto);

Lo cual devolverá un valor booleano que deberá ser verdadero ante la igualdad de los objetos o falso en el caso contrario. Para cumplir con esa premisa, tenemos que considerar ciertos pasos.

Por empezar, tenemos que evitar que el código avance cuando no sea necesario. Considerando esto, podríamos iniciar el cuerpo del método mediante una simple pregunta que nos ahorrará muchos pasos: ¿es acaso el objeto que recibo por parámetro el mismo objeto que recibe la llamada al método? En otras palabras... ¿me estoy comparando conmigo mismo? De ser así, simplemente se devolverá un valor verdadero y el asunto quedará resuelto:

public boolean equals(Object obj) {
    if (this == obj){
        return true;
    }
}

Esto no es todo, por supuesto. El código aún no compila (ya que no podemos evitar la sentencia del return), pero no deja de ser un muy buen primer paso: Ahora estamos tranquilos, sabiendo que si el código se invoca de una manera reflexiva, el resultado es correcto.

Siguiendo con el análisis, consideramos la opción de otro valor especial en el parámetro: el null. Imaginemos que se nos pide comparar un objeto contra un valor nulo: por supuesto será diferente al objeto en cuestión.
En este caso, adicionalmente, estaríamos salvando un error a futuro si preguntamos por la existencia de null, dado que si el argumento tuviese ese valor se podría llegar a librar una NullPointerException cuando intentemos comparar los atributos miembro del objeto. En código, sería así:

public boolean equals(Object obj) {
    if (this == obj){
        return true;
    }
    if (obj == null){
        return false;
    }
}

Una vez más, el código no compila, pero nos comenzamos a asegurar de que caminamos sobre terreno firme. Un último error que deberíamos contemplar es si realmente estamos recibiendo un objeto del tipo que esperamos (i.e. si estamos comparando Personas, no podemos recibir Animales). Esto se logra verificando la clase del objeto parámetro, y comparándola con la clase del objeto que recibe el mensaje. El código es más claro que la explicación:

public boolean equals(Object obj) {
    if (this == obj){
        return true;
    }
    if (obj == null){
        return false;
    }
    if (getClass() != obj.getClass()){
        return false;
    }
}

Por supuesto, si las clases son diferentes los objetos serán distintos. Ahora bien, pasaremos a dar todos los demás pasos juntos para terminar con el código funcional de un equals que se comporta como queremos.

Necesitaremos convertir el objeto a la clase correspondiente (en este caso, Persona). Es importante destacar que la conversión de tipos podría haber generado una ClassCastException, pero está protegido por las sentencias predecesoras que comprueban el tipo del objeto parámetro.
Una vez convertido el parámetro al tipo necesario, deberemos comparar todos o algunos de sus atributos (próximamente escribiremos sobre esta decisión). Si todos los atributos comparados se corresponden, la igualdad es inmediata. Si no, los objetos serán diferentes. Como es más fácil comprobar la diferencia y cortar por el error, que cortar por la "no igualdad de todos los atributos" (como lo enuncia la Ley de De Morgan), el código se escribe por la negación. Vemos el equals terminado:

public boolean equals(Object obj) {
    if (this == obj){
        return true;
    }
    if (obj == null){
        return false;
    }
    if (getClass() != obj.getClass()){
        return false;
    }
    Persona other = (Persona) obj;
    if (documento != other.documento){
        return false;
    }
    if (nombre == null) {
        if (other.nombre != null){
            return false;
        }
    } else if (!nombre.equals(other.nombre)){
        return false;
    }
    return true;
}

Nótese cómo cuando comparamos atributos que son referencias y no tipos primitivos, primero chequeamos las condiciones de nulidad de la variable local, luego la de la variable propia del objeto parámetro, y en caso de que no sea nula la local, se reutiliza el método equals del atributo dentro del objeto (tómense un minuto para releer esta frase y ver si la comprendieron bien).
La magia del equals se ve potenciada cuando podemos reutilizar el código de otro equals previamente codificado. En este caso, el equals de la clase String provista por Java.

Creo que con esta nota ya los mareamos lo suficiente, pero seguramente habrá muchas más sobre temas afines a la identidad e igualdad en Java. Y ahora, les pregunto a ustedes: ¿utilizan otra implementación de equals?

Igualdad de objetos en Java (I)

Al poco tiempo de empezar a programar en Java, nos encontramos con que debemos evaluar la igualdad de los objetos, para hacer cosas en función de eso. Entonces hacemos:

Persona personaUno = new Persona("Lucas Videla", 23456789);
Persona personaDos = new Persona("Matías González", 12345678);

if (personaUno == personaDos){
    // hacer algo
}

Probamos el código, y quizás durante un tiempo no notemos que en realidad no funciona como corresponde: siempre arroja falso. Nos quedamos perplejos, dado que cuando hacíamos esto, el código funcionaba perfectamente:

int unEntero = 5;
int otroEntero = 6;

if (unEntero == otroEntero){
    // hacer algo
}

Luego de un tiempo caemos en cuenta de que lo que está sucediendo es que la comparación no está haciendo lo que queremos: está comparando otra cosa.
En Java, el operador == compara el contenido de dos variables dadas, sean éstas del tipo que sean.
Para los enteros funciona, por ejemplo, porque la variable almacena el valor efectivo del entero. Para los números de punto flotante también, y así sucesivamente en los tipos primitivos.
Pero cuando nos encontramos con los objetos vemos que el criterio no funciona, ya que la variable almacena una referencia a otro espacio de memoria donde realmente está el objeto. Por lo tanto, comparará si las referencias son iguales, es decir, si apuntan al mismo lugar. En ese caso, sólo obtendremos un valor verdadero en el caso de que realmente sea el mismo objeto. Y esto casi nunca es admisible para los criterios de negocio.

Para solventar esto Java nos proporciona un mecanismo para la comparación por igualdad entre dos objetos, implementada a nivel de Object (y por lo tanto heredada por toda clase que desarrollemos). Estamos hablando del método equals, el cual tiene la siguiente firma:

public boolean equals(Object obj);

Recapitulando: el operador de comparación por igualdad (==) no funciona para los objetos. O mejor dicho, sí funciona, pero no de la forma en la que nos es útil. Por lo tanto necesitábamos un nuevo mecanismo. Y allí entra en juego la clase Object con su método al rescate: equals.
La implementación por defecto (es decir, la que tendremos a menos que hagamos algo para evitarlo) es ésta:

public boolean equals(Object obj) {
    return (this == obj);
}

Por lo tanto, vemos que se comporta de la misma manera que el operador. En principio, la comparación por igualdad arrojará el mismo resultado que la utilización del método equals.
Entonces... ¿qué debemos hacer? Debemos sobreescribir el método, para nuestra clase en particular.

Aquí vemos cómo sobreescribir el método equals, para la clase Persona:

public class Persona{
    private String nombre;
    private int documento;

    public Persona(String nombre, int documento){
        this.nombre = nombre;
        this.documento = documento;
    }

    public boolean equals(Object obj){
        boolean retorno;
        // código para definir el criterio de igualdad
        // y establecer el valor de retorno
        return retorno;
    }
}

Ahora bien, tenemos la estructura donde escribir el código que evaluará la igualdad de los objetos. Pero... ¿qué escribir en dicho método?
Ese asunto es un tanto complejo, y lo voy adejar para una segunda parte de este artículo.