La clase Object tiene un método llamado 'equals' y normalmente las subclases proceden a sobreescribirlo y definir un algoritmo acorde a su objetivo.
La clase Object declara el método 'equals' con la siguiente sintaxis:
public boolean equals(Object obj)
Veamos un ejemplo que sobreescriba el método equals para una clase cualquiera.
Problema:
Plantear una clase llamada 'Punto' que represente un punto en el plano. Definir los atributos x e y.
Sobreescribir el método 'equals' y definir como lógica que retorne true si los atributos x e y son iguales.
Clase: Punto
public class Punto {
private int x, y;
public Punto(int x, int y) {
this.x = x;
this.y = y;
}
public boolean equals(Object obj) {
Punto punto = (Punto) obj;
if (x == punto.x && y == punto.y)
return true;
else
return false;
}
public static void main(String[] ar) {
Punto punto1 = new Punto(10, 2);
Punto punto2 = new Punto(10, 2);
Punto punto3 = new Punto(20, 4);
if (punto1.equals(punto2))
System.out.println("punto1 y punto2 pertenecen al mismo punto en el plano.");
if (punto1.equals(punto3))
System.out.println("punto1 y punto3 pertenecen al mismo punto en el plano.");
else
System.out.println("punto1 y punto3 no pertenecen al mismo punto en el plano.");
}
}
La firma del método equals debe ser igual que el declarado en la clase Object:
public boolean equals(Object obj) {
Lo primero que hacemos es mediante casting convertir el parámetro 'Object' a tipo 'Punto':
Punto punto = (Punto) obj;
Luego ya podemos verificar si los atributos x e y coinciden con las referencias x e y del parámetro 'obj':
if (x == punto.x && y == punto.y)
return true;
else
return false;
}
En la main creamos tres objetos de la clase Punto y llamamos al método equals que hemos implementado:
public static void main(String[] ar) {
Punto punto1 = new Punto(10, 2);
Punto punto2 = new Punto(10, 2);
Punto punto3 = new Punto(20, 4);
if (punto1.equals(punto2))
System.out.println("punto1 y punto2 pertenecen al mismo punto en el plano.");
if (punto1.equals(punto3))
System.out.println("punto1 y punto3 pertenecen al mismo punto en el plano.");
else
System.out.println("punto1 y punto3 no pertenecen al mismo punto en el plano.");
}
Luego tenemos como resultado:
Tener en cuenta que en Java no es lo mismo utilizar el operador == ya que en ese caso estamos verificando si las variables apuntan al mismo objeto:
Punto punto1 = new Punto(10, 2);
Punto punto2 = new Punto(10, 2);
if (punto1==punto2)
System.out.println("Apuntan al mismo objeto");
else
System.out.println("No apuntan al mismo objeto");
El if se verifica falso ya que punto1 y punto2 tienen direcciones de objetos distintos.
En cambio si tenemos el código siguiente:
Punto punto1 = new Punto(10, 2);
Punto referencia = punto1;
if (punto1==referencia)
System.out.println("Apuntan al mismo objeto");
else
System.out.println("No apuntan al mismo objeto");
El if se verifica verdadero ya que las variables 'punto1' y 'referencia' almacenan la dirección del mismo objeto que creamos con el operador 'new'.
Hay que tener en cuenta que al método 'equals' nosotros le definimos la semántica de igualdad para dos objetos.
Problema propuesto
-
Crear una clase Persona y definir los atributos nombre, edad y dni.
Sobreescribir el método 'equals' de tal forma que retorne true si los dni son iguales.
public class Persona {
private String nombre;
private int edad;
private String dni;
public Persona(String nombre, int edad, String dni) {
this.nombre = nombre;
this.edad = edad;
this.dni = dni;
}
public boolean equals(Object obj) {
Persona persona = (Persona) obj;
if (dni.equals(persona.dni))
return true;
else
return false;
}
public static void main(String[] ar) {
Persona persona1 = new Persona("juan", 22, "20456123");
Persona persona2 = new Persona("ana", 15, "21100200");
Persona persona3 = new Persona("juan", 22, "20456123");
if (persona1.equals(persona2))
System.out.println("persona1 y persona2 si son la misma persona");
else
System.out.println("persona1 y persona2 no son la misma persona");
if (persona1.equals(persona3))
System.out.println("persona1 y persona3 si son la misma persona");
}
}