Clase Object

Como ya indicamos en el tema introductorio de POO, la clase Object es una clase especial de la que heredan todas la clases en Java. Es la superclase que se sitúa en la cúspide de la estructura de herencias entre clases

La siguiente clase

class Vehiculo{
    . . .
}

en realidad equivale a

class Vehiculo extends Object{
    String tipo;
    String color;
    . . .
}

La clase Object tiene una serie de métodos que todas las clases heredan por defecto

Método toString()

El método toString() es un método de la clase Object que se puede sobrescribir en cualquier clase para proporcionar una representación de cadena (String) significativa de la instancia de esa clase

Por defecto, la implementación en la clase Object devuelve una cadena que consiste en el nombre de la clase seguido por el signo "@" y la representación hexadecimal del valor del identificador del objeto en memoria

public  static void main(String[] args){
    Vehiculo coche=New Vehiculo("coche","rojo");
    //imprime algo parecido a: Vehiculo@2a139b44
    System.out.println(coche.toString());
}

Sin embargo, este comportamiento predeterminado suele ser insuficiente para representar de manera útil la información de un objeto.

Al sobrescribir el método toString() en una clase específica, puedes proporcionar una representación más significativa y personalizada del objeto en forma de cadena.

    class Vehiculo extends Object{
    String tipo;
    String color;
   // Constructor y métodos de la clase . . .

   // Sobrescribir el método toString para proporcionar una representación significativa
    @Override
    public String toString() {
        return "Vehiculo {tipo='" + tipo + "', color=" + color + "}";
    }
}

Cuando es necesaria una transformación a String, Java llama automáticamente al método toString(), por lo que puedes simplemente usar:

    System.out.println(coche);

Método equals()

En Java, el método equals() se utiliza para comparar la igualdad de dos objetos. Este método está definido en la clase Object, que es la clase base para todas las clases en Java. Sin embargo, es común que las clases personalizadas sobrescriban este método para proporcionar una implementación específica de la igualdad entre dos objetos de la misma clase.

La firma del método equals() en la clase Object es la siguiente:

 public boolean equals(Object obj)

Por ejemplo:

Para una clase Persona en la que queremos determinar que dos personas son iguales si su dni es igual

public class Persona {
    private String nombre;
    private String dni;

    // Constructor y otros métodos de la clase

    // Sobrescribir el método equals para comparar personas por su DNI
    @Override
    public boolean equals(Object obj) {
       // Verificar si es el mismo objeto
        if (this == obj) {
            return true;
        }

        // Verificar si el objeto no es nulo y pertenece a la misma clase
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }

        // Convertir el objeto a la misma clase y comparar DNI
        Persona otraPersona = (Persona) obj;
        return dni.equals(otraPersona.dni);
    }
}

Podemos comparar los objeto

public static void main(String[] args) {
        Persona juan = new Persona("Juan", "12345678A");
        Persona maria = new Persona("Maria", "87654321B");
        Persona juanito = new Persona("Juanito", "12345678A");

        // Comprobando la igualdad
        System.out.println("persona1 equals persona2: " + juan.equals(maria)); // false
        //el dni es el mismo
        System.out.println("persona1 equals persona3: " + juan.equals(juanito)); // true
    }

'equals' vs '=='

Es importante tener en cuenta, que una variable que instancia a un objeto, tiene la dirección a dicho objeto. Por lo que si dos variables se comparan con ==, nos dará true si la dirección en la misma y no su contenido.

Alumno a=new Alumno("Maria");
Alumno c=new Alumno("Maria");
Alumno b=a;

System.out.println(a.equals(c)); // true
System.out.println(a==b); // true
System.out.println(a==c); // false

Importancia de sobrescribir 'equals'

Otras clases utilizan equals para comparar si sus elementos son iguales, por ejemplo, el método Arrays.equals o indexOf de la clase ArrayList

public static void main(String[] args) {
        Persona persona1 = new Persona("Juan", "12345678A");
        Persona persona2 = new Persona("Maria", "87654321B");
        Persona persona3 = new Persona("Juanito", "12345678A");

        // Comprobando la igualdad usando el método equals de Persona
        System.out.println("persona1 equals persona2: " + persona1.equals(persona2)); // false
        System.out.println("persona1 equals persona3: " + persona1.equals(persona3)); // true

        // Creando arrays de Personas
        Persona[] array1 = {persona1, persona2};
        Persona[] array2 = {persona3, new Persona("Marieta", "87654321B")};

        // Comprobando la igualdad de los arrays usando Arrays.equals
        System.out.println("Arrays.equals(array1, array2): " + Arrays.equals(array1, array2)); // true

    }

IntelliJ y equals()

IntelliJ nos permite generar automáticamente el método equals junto a hashCode(necesario para ciertas clases)

Conclusión

Debemos sobrescribir siempre los métodos toString y equals en nuestras clases para permitir imprimir el contenido de la clase y poder comparar objetos de la misma clase