En Java la superclase de todas las clases es la clase Object, y todas las clases heredan los métodos de esta clase. Cada vez que una clase hereda un método o constructor de una superclase, se tiene la oportunidad de sobrescribir el funcionamiento del método.

La sobrescritura de métodos heredados se usa para definir el comportamiento específico de un método que tiene un funcionamiento demasiado general en una superclase. Esto se denomina Override.

Cuando sobrescribimos métodos podemos ayudar al compilador a evaluar si hacemos lo correcto utilizando la etiqueta @Override en la definición del método. Esto se comenta con más detalle en la sección sobre Herencia de Clases.

La clase Object tiene una serie de métodos, aunque solo sobrescribiremos los métodos que consideremos necesarios:

Dependiendo de la finalidad de nuestra clase nos podría interesar sobrescribir unos métodos u otros. Los métodos más comunes a la hora de sobrescribir son: toString(), equals(), clone() y hashCode().

Eclipse ofrece la posibilidad de generar de forma automática estos algunos métodos de la clase Object. Desde la pestaña Soruce del menu, o haciendo clic derecho en el editor de texto → Source accedemos al siguiente menu:

Pulsando sobre la generación de esos métodos, eclipse nos ayuda a generarlos. El método toString() crea un String utilizando el valor de todos los atributos. Podemos modificarlo si queremos mostrar menos, o dar otro formato.

Tal como se indica en la documentación de la clase Object, el método toString() se usa para obtener una “representacion textual” de un objeto.

El método toString() está enfocado en la representación de un objeto hacia el usuario. La información que muestra debe ser concisa pero explicativa para que lo entienda una persona.

El método de la clase Object devuelve un String compuesto por el nombre de la clase, una @, y el código hash en hexadecimal de ese objeto.

Cuando nosotros creamos una clase, puede que la información genérica del método original no nos sirva de mucho. Por lo que se recomienda que todas las subclases de Object lo sobrescriban.

Es el creador de la clase quien debe elegir qué información considera oportuna para representar al objeto.

public class Persona{
   private String dni;
   private String nombre;
   private String apellido1;
   private String apellido2;
   private LocalDate fechaNacimiento;
   private float altura;
   private float peso;
   private String colorOjos;
   private String complexion;
 
   @Override
   public String toString(){
      return dni + " - " + nombre + " " + apellido1 + " " + apellido2;
   }
}

Una de las mayores ventajas de crear el método toString() es que podemos mostrar por consola una variable de referencia de una clase, y automáticamente se llamará al método toString() de esa clase.

Persona persona1 = new Persona();
System.out.println(persona1); // Se ejecuta implicitamente el método toString()

El método equals se usa para saber si un objeto es igual a otro, devolviendo true o false.

Cuando dos objetos pertenecen a distinta clase, es fácil evaluarlo. Pero cuando dos objetos pertenecen a la misma clase, aunque sean objetos distintos, nos podría interesar establecer un criterio para indicar cuando son iguales.

Por ejemplo:

• Con dos objetos String distintos, el método equals() devuelve true si contienen la misma cadena de texto.
• Con dos objetos LocalDate distintos, el método equals() devuelve true cuando representan la misma fecha.

El método equals() de la clase Object indica true únicamente cuando se trata del mismo objeto creado (ambas variables contienen la dirección del mismo objeto), como se explica en el siguiente ejemplo:

Persona persona1 = new Persona();
Persona persona2;
 
//Las dos variables de referencia contienen la misma dirección de memoria
//Es decir, apuntan o referencian al mismo objeto
persona2 = persona1;
 
//Entonces el método equals heredado de Object
persona1.equals(persona2); //Devuelve true
 
//Pero si contienen referencias a objetos distintos
persona2 = new Persona();
 
persona1.equals(persona2); //Devuelve false

Aunque establecer un criterio para comparar 2 objetos es bastante sencillo (por ejemplo 2 personas son iguales si tienen el mismo dni), se deben cumplir unas normas.

Se definen unas normas que toda implementación del método equals() que se precie, debe cumplir.

• Debe ser reflexivo; para x distinto de null, x.equals(x) devuelve true.
• Debe ser simétrico; para x e y distintos de null, x.equals(y) == y.equals(x).
• Debe ser transitivo; para x, y y z distintos de null, si x.equals(y) es true, y y.equals(z) es true, entonces x.equals(z) debe ser true.
• Debe ser consistente; para x e y distintos de null, todas las llamadas a x.equal(y) devuelven siempre el mismo valor, mientras no cambien el valor de los atributos comparados.
• Si x es distinto de null, x.equals(null) debe ser false.

Atendiendo a esto podemos seguir el siguiente patrón a la hora de sobrescribir este método:

public class Persona{
   private String dni;
   private String nombre;
   private int edad;
 
   @Override 
   public boolean equals(Object obj){
      if (this == obj){
         return true;
      }
      if (obj == null){
	 return false;
      }
      if (this.getClass() != obj.getClass()){
	 return false;
      }
      Vehiculo other = (Vehiculo) obj;
      if ( ! ((this.dni.equals(obj.dni) 
         && (this.nombre.equals(obj.nombre))
         && (this.edad == obj.edad))){
           return false;
      }
      return true;
   }
}

Si puede que nuestros objetos se almacenen el algún tipo de estructura Hash debemos de crear sobrescribir el método hashCode() en concordancia con el método equals().

© 2025 Fernando Valdeón