java.lang.Object Class Methods

Every class in Java implicitly extends Object. Its 11 methods form the foundation of identity, synchronization, and lifecycle management in the JVM.

All 11 Methods — Category Map

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph IDENTITY["Identity & Type"]
        direction TB
        M1["equals(Object)"]
        M2["hashCode()"]
        M3["getClass()"]
    end

    subgraph DISPLAY["String Repr"]
        direction TB
        M4["toString()"]
    end

    subgraph SYNC["Thread Coordination"]
        direction TB
        M5["wait()"]
        M6["wait(long)"]
        M7["wait(long, int)"]
        M8["notify()"]
        M9["notifyAll()"]
    end

    subgraph LIFECYCLE["Lifecycle"]
        direction TB
        M10["clone()"]
        M11["finalize()"]
    end

    style IDENTITY fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style DISPLAY fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style SYNC fill:#FEF3C7,stroke:#FCD34D,color:#92400E
    style LIFECYCLE fill:#FEE2E2,stroke:#FCA5A5,color:#991B1B
    style M1 fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
    style M2 fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
    style M3 fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
    style M4 fill:#ECFDF5,stroke:#6EE7B7,color:#065F46
    style M5 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style M6 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style M7 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style M8 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style M9 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style M10 fill:#FEF2F2,stroke:#FCA5A5,color:#991B1B
    style M11 fill:#FEF2F2,stroke:#FCA5A5,color:#991B1B

toString()

Default Behavior

Object obj = new Object();
System.out.println(obj.toString());
// Output: java.lang.Object@1b6d3586
// Format: getClass().getName() + "@" + Integer.toHexString(hashCode())

The default output is useless for debugging — it shows the class name and the identity hash code (memory-derived).

Proper Override

public class Employee {
    private int id;
    private String name;
    private String dept;

    @Override
    public String toString() {
        return "Employee{id=%d, name='%s', dept='%s'}".formatted(id, name, dept);
    }
}
// Output: Employee{id=42, name='Vamsi', dept='Engineering'}

Best practices:

• Include all meaningful fields
• Use a format that is human-readable and parseable in logs
• Never include sensitive data (passwords, tokens)
• Lombok: @ToString generates it automatically
• Records: auto-generated from all components

equals()

The Contract (from Javadoc)

Correct Template

@Override
public boolean equals(Object o) {
    if (this == o) return true;                            // 1. Reference check
    if (o == null || getClass() != o.getClass()) return false; // 2. Null + type check
    Employee that = (Employee) o;                          // 3. Cast
    return id == that.id                                   // 4. Compare fields
        && Objects.equals(name, that.name)
        && Objects.equals(dept, that.dept);
}

Common Mistakes

hashCode()

Contract with equals()

1. If a.equals(b) is true then a.hashCode() == b.hashCode() MUST be true
2. If a.equals(b) is false then hashCodes MAY or MAY NOT differ (but should, for performance)
3. Consistency: same value across multiple calls in one execution (may differ across JVM restarts)

Algorithm Choices

// Manual high-performance hashCode
@Override
public int hashCode() {
    int result = Integer.hashCode(id);
    result = 31 * result + (name != null ? name.hashCode() : 0);
    result = 31 * result + (dept != null ? dept.hashCode() : 0);
    return result;
}

Why 31? It is an odd prime. The JVM optimizes 31 * i to (i << 5) - i. Good distribution with minimal collisions.

clone()

Shallow vs Deep Copy

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph SHALLOW["Shallow Clone"]
        direction TB
        S1["Original Object"]
        S2["Cloned Object"]
        S3["Shared Reference"]
        S1 --> S3
        S2 --> S3
    end

    subgraph DEEP["Deep Clone"]
        direction TB
        D1["Original Object"]
        D2["Cloned Object"]
        D3["Original Ref"]
        D4["Copied Ref"]
        D1 --> D3
        D2 --> D4
    end

    style SHALLOW fill:#FEF3C7,stroke:#FCD34D,color:#92400E
    style DEEP fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style S1 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style S2 fill:#FFFBEB,stroke:#FCD34D,color:#92400E
    style S3 fill:#FEE2E2,stroke:#FCA5A5,color:#991B1B
    style D1 fill:#ECFDF5,stroke:#6EE7B7,color:#065F46
    style D2 fill:#ECFDF5,stroke:#6EE7B7,color:#065F46
    style D3 fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
    style D4 fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF

How clone() Works

public class Address implements Cloneable {
    String city;
}

public class Employee implements Cloneable {
    int id;
    String name;
    Address address;  // mutable reference

    @Override
    public Employee clone() {
        try {
            Employee copy = (Employee) super.clone();  // shallow copy
            copy.address = new Address(address.city);  // deep copy mutable fields
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();  // should never happen
        }
    }
}

Why clone() Is Broken (Effective Java, Item 13)

Alternatives to clone()

// 1. Copy constructor (preferred)
public Employee(Employee other) {
    this.id = other.id;
    this.name = other.name;
    this.address = new Address(other.address.city);
}

// 2. Static factory
public static Employee copyOf(Employee other) {
    return new Employee(other.id, other.name, new Address(other.address.city));
}

// 3. Serialization-based deep copy (heavy but generic)

finalize() — Deprecated Since Java 9

Why finalize() Is Dangerous

Resurrection Problem

public class Zombie {
    static Zombie instance;

    @Override
    protected void finalize() {
        instance = this;  // object resurrects itself!
        // GC cannot collect it — it's reachable again
    }
}

Alternatives

// 1. try-with-resources (preferred for I/O)
try (var conn = dataSource.getConnection()) {
    // use connection
}  // auto-closed here

// 2. java.lang.ref.Cleaner (Java 9+)
private static final Cleaner CLEANER = Cleaner.create();

public class Resource {
    private final Cleaner.Cleanable cleanable;

    public Resource() {
        State state = new State(/* native resource */);
        this.cleanable = CLEANER.register(this, state);
    }

    // State must NOT reference the Resource (prevent leak)
    private static class State implements Runnable {
        @Override
        public void run() { /* release native resource */ }
    }

    public void close() {
        cleanable.clean();  // explicit cleanup
    }
}

getClass()

Returns the runtime Class<?> object. Cannot be overridden (it is final).

Object obj = "Hello";
Class<?> cls = obj.getClass();

cls.getName();         // "java.lang.String"
cls.getSimpleName();   // "String"
cls.getSuperclass();   // class java.lang.Object
cls.getInterfaces();   // [Serializable, Comparable, CharSequence, ...]

Generics Erasure

List<String> strings = new ArrayList<>();
List<Integer> ints = new ArrayList<>();

// Both return class java.util.ArrayList at runtime
strings.getClass() == ints.getClass();  // TRUE — generics are erased

// Cannot do: if (obj instanceof List<String>) — compiler error
// Can do:    if (obj instanceof List<?>) — wildcard only

Use Cases

wait() / notify() / notifyAll()

Monitor Mechanism

Every Java object has an intrinsic lock (monitor). The wait/notify mechanism allows threads to coordinate using this monitor.

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph MONITOR["Object Monitor"]
        direction TB
        L["Lock (synchronized)"]
        WS["Wait Set"]
    end

    T1["Thread A\n(holds lock)"] -->|"calls wait()"| WS
    WS -->|"notify() called"| T2["Thread A\n(re-acquires lock)"]
    T3["Thread B\n(holds lock)"] -->|"calls notify()"| WS

    style MONITOR fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style L fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
    style WS fill:#FEF3C7,stroke:#FCD34D,color:#92400E
    style T1 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style T2 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style T3 fill:#ECFDF5,stroke:#6EE7B7,color:#065F46

Spurious Wakeups and the Proper Pattern

A thread can wake from wait() without being notified (spurious wakeup). You MUST always use a while-loop guard.

// WRONG — if/single check
synchronized (lock) {
    if (!condition) {
        lock.wait();  // spurious wakeup resumes here with condition still false!
    }
    // proceed — BUG: condition might be false
}

// CORRECT — while-loop guard
synchronized (lock) {
    while (!condition) {     // re-check after every wakeup
        lock.wait();
    }
    // proceed — condition is guaranteed true
}

Producer-Consumer Example

public class BoundedBuffer<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;
    private final Object lock = new Object();

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        synchronized (lock) {
            while (queue.size() == capacity) {   // full — wait
                lock.wait();
            }
            queue.add(item);
            lock.notifyAll();                    // signal consumers
        }
    }

    public T take() throws InterruptedException {
        synchronized (lock) {
            while (queue.isEmpty()) {            // empty — wait
                lock.wait();
            }
            T item = queue.poll();
            lock.notifyAll();                    // signal producers
            return item;
        }
    }
}

notify() vs notifyAll()

Rule of thumb: Prefer notifyAll(). Using notify() risks waking a thread that cannot proceed, leaving the actual target thread still waiting.

Comparison Table

Quick Recall Mnemonics

Interview Answer Template