Object Class and Its Methods

Core Methods Inherited from Object

A handful of Object methods are overridden constantly in everyday Java code, because their default behavior is rarely what a class actually needs.

• toString() — returns a String representation of the object; the default prints the class name plus a hash code in hex, which is rarely useful and almost always worth overriding.
• equals(Object obj) — compares two objects for logical equality; the default implementation only checks reference identity (the same object in memory).
• hashCode() — returns an integer used by hash-based collections like HashMap and HashSet to bucket objects efficiently.
• getClass() — returns the runtime Class object representing the object's actual class, useful for reflection and type checks.

The equals() and hashCode() Contract

Java requires a strict rule: if two objects are equal according to equals(), they must return the same value from hashCode(). The reverse is not required — equal hash codes do not imply the objects are equal (that is simply a hash collision). Breaking this contract by overriding one method but not the other causes subtle bugs where an object that "equals" another cannot be found in a HashMap or HashSet, because it lands in the wrong bucket.

Overriding These Methods Correctly

When you override equals(), you should also override hashCode() using the same fields that participate in the equality check, so the contract holds. Most IDEs and the java.util.Objects helper class (Objects.equals(), Objects.hash()) make this straightforward and less error-prone than writing it by hand.

Example

import java.util.Objects;

class Point {
    int x, y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Point)) return false;
        Point other = (Point) obj;
        return x == other.x && y == other.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

public class ObjectMethodsDemo {
    public static void main(String[] args) {
        Point p1 = new Point(1, 2);
        Point p2 = new Point(1, 2);
        System.out.println(p1);
        System.out.println(p1.equals(p2));
        System.out.println(p1.hashCode() == p2.hashCode());
        System.out.println(p1.getClass().getName());
    }
}

Point(1, 2)
true
true
Point

Exercise

Two Email objects should be equal when their addresses match, ignoring upper and lower case. At the moment the program prints false. Override equals() and hashCode() so it prints true.

import java.util.HashSet;
import java.util.Set;

class Email {
    private final String address;

    Email(String address) {
        this.address = address;
    }

    // TODO: override equals() to compare addresses ignoring case
    // TODO: override hashCode() so equal emails have the same hash code
}

public class EmailDemo {
    public static void main(String[] args) {
        Set<Email> seen = new HashSet<>();
        seen.add(new Email("Asha@Example.com"));
        System.out.println(seen.contains(new Email("asha@example.com")));
    }
}

import java.util.HashSet;
import java.util.Set;

class Email {
    private final String address;

    Email(String address) {
        this.address = address;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Email)) {
            return false;
        }
        return address.equalsIgnoreCase(((Email) other).address);
    }

    @Override
    public int hashCode() {
        return address.toLowerCase().hashCode();
    }
}

public class EmailDemo {
    public static void main(String[] args) {
        Set<Email> seen = new HashSet<>();
        seen.add(new Email("Asha@Example.com"));
        System.out.println(seen.contains(new Email("asha@example.com"))); // true
    }
}

Quick quiz

Interview questions

Go deeper

• How HashMap Works Internally