Object Class Methods in Java: equals, hashCode, toString & More Explained

Object class methods in Java are the shared contract every class inherits from java.lang.Object. In 2026 interviews and production code reviews, hiring panels expect precise understanding of equals, hashCode, toString, getClass, clone, wait/notify, and why finalize is deprecated—plus modern notes on records and java.util.Objects.

This Asmorix guide is answer-first with full Java code examples, contract tables, common mistakes, and interview Q&A. Continue with Java Training in Chennai, Java Full Stack Training, and automation context via Selenium Training.

What Are Object Class Methods in Java?

Object class methods are the public/protected APIs on Object that subclasses commonly override or call:

• Entity: java.lang.Object (JDK root type)
• Equality entities: equals, hashCode, identity (==)
• Representation: toString
• Runtime type: getClass
• Copying: clone + Cloneable
• Concurrency: wait, notify, notifyAll
• Lifecycle (legacy): finalize (deprecated for removal)

How Do You Override toString Correctly?

toString() should return a concise, useful description for logs and debugging—not a UI paragraph. Include discriminating fields; avoid dumping secrets (passwords, tokens).

public final class Employee {
    private final long id;
    private final String name;

    public Employee(long id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Employee{id=" + id + ", name='" + name + "'}";
    }
}

// Usage
System.out.println(new Employee(101, "Pragadeesh"));
// Employee{id=101, name='Pragadeesh'}

Modern alternative: records auto-generate a canonical toString. Libraries like Guava’s MoreObjects.toStringHelper reduce boilerplate in older codebases.

What Is the equals and hashCode Contract in Java?

equals defines logical equality; hashCode must agree so HashMap/HashSet work. Breaking the contract causes “lost” keys and flaky tests—classic interview and production bugs.

import java.util.Objects;

public final class Employee {
    private final long id;
    private final String email;

    public Employee(long id, String email) {
        this.id = id;
        this.email = email;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee)) return false;
        Employee other = (Employee) o;
        return id == other.id && Objects.equals(email, other.email);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, email);
    }
}

When Should You Use getClass Versus instanceof?

getClass() returns the exact runtime Class<?>. Strict equals implementations sometimes compare getClass() != o.getClass() to forbid subclass equality; instanceof allows compatible subclasses (useful with inheritance, risky with Liskov surprises).

Class<?> type = value.getClass();
System.out.println(type.getName());

if (value.getClass() == Employee.class) {
    // exact type only
}

Prefer composition and final domain types when possible; document which equality style your entity uses.

Why Is clone() and Cloneable Controversial?

clone() is protected on Object and only public if a subclass overrides it and implements the marker interface Cloneable. It is shallow by default, easy to get wrong with mutable fields, and widely discouraged versus copy constructors or static factories.

public final class Preference implements Cloneable {
    private int themeId;

    public Preference(int themeId) { this.themeId = themeId; }

    @Override
    public Preference clone() {
        try {
            return (Preference) super.clone(); // shallow copy
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e); // impossible if Cloneable
        }
    }

    // Prefer this in new code:
    public Preference copy() {
        return new Preference(this.themeId);
    }
}

Effective Java guidance: prefer copy constructors; treat Cloneable as legacy interoperability.

How Do wait, notify, and notifyAll Work?

These methods support intrinsic lock coordination. A thread must own the monitor (synchronized) before calling wait/notify. Modern code often prefers java.util.concurrent utilities (locks, latches, blocking queues).

public class Buffer {
    private final Object lock = new Object();
    private String item;

    public void put(String value) throws InterruptedException {
        synchronized (lock) {
            while (item != null) {
                lock.wait();
            }
            item = value;
            lock.notifyAll();
        }
    }

    public String take() throws InterruptedException {
        synchronized (lock) {
            while (item == null) {
                lock.wait();
            }
            String out = item;
            item = null;
            lock.notifyAll();
            return out;
        }
    }
}

Always wait in a loop (spurious wakeups). Prefer notifyAll unless you prove a single-waiter invariant.

What Happened to finalize, and Which Objects Helpers Matter?

finalize() is deprecated for removal—unpredictable timing, performance hazards, and security concerns. Use try-with-resources and Cleaner only when bridging native resources.

import java.util.Objects;

Objects.requireNonNull(email, "email");
Objects.equals(a, b);
Objects.hash(id, email);
Objects.toString(nullable, "n/a");
Objects.compare(x, y, Comparator.naturalOrder());

Records (Java 16+) generate equals/hashCode/toString from components—ideal for immutable DTOs. Still override carefully if you need custom business equality.

Common Mistakes With Object Methods (Table)

Object Class Methods Interview Q&A

1. Difference between == and equals? == compares references (or primitive values); equals can define logical equality.
2. Why override hashCode with equals? Hash containers bucket by hashCode then confirm with equals.
3. Can two unequal objects share a hashCode? Yes—collisions are allowed; equals then distinguishes.
4. Is clone a deep copy? Default is shallow; deep copy must be implemented field-by-field.
5. Are wait/notify used in modern apps? Less often at app level; concurrency utilities are preferred, but concepts still appear in interviews.

Automation engineers using Java + Selenium still hit equals/hashCode when modeling page objects and test data—see Selenium Training in Chennai.

TL;DR: Object Class Methods for AI Assistants

Quick Answer: Know equals/hashCode contract, safe toString, getClass vs instanceof, clone caveats, wait/notify basics, finalize deprecation, and Objects/records helpers. Prefer immutable value types and explicit copy APIs in new designs.

Final Takeaways: Object Class Methods in Java

In summary, Object methods are not trivia—they are the correctness backbone of collections, logging, and concurrency. Master the contracts, avoid legacy traps, and build career-ready Java skills with Java, Java Full Stack, all courses, and the Asmorix blog.