Object Class Methods

🎭 The Secret Identity of Every Java Object

A story about how objects know who they are, recognize their twins, and make perfect copies of themselves

🏠 Meet the Object Class: The Great-Great-Grandparent

Imagine every person in the world has the same great-great-great-grandparent. In Java, every single object has the same ancestor too — it’s called the Object class.

// Even if you write this:
class Dog { }

// Java secretly sees:
class Dog extends Object { }

Why does this matter?

The Object class gives EVERY object in Java some superpowers — like:

• Describing itself (toString)
• Checking if it’s equal to another object (equals)
• Creating a special ID number (hashCode)
• Making copies of itself (clone)

Think of it like a family recipe book that gets passed down. Every family member inherits these recipes!

graph TD
    A["Object Class"] --> B["Your Dog Class"]
    A --> C["Your Cat Class"]
    A --> D["String Class"]
    A --> E["Every Other Class"]
    style A fill:#FFD700,stroke:#333

📝 The toString Method: Teaching Objects to Introduce Themselves

The Problem

Imagine you have a new friend, but when you ask their name, they say:

“I am Person@4a574795”

That’s confusing, right? That’s what Java objects do by default!

class Person {
    String name = "Alice";
    int age = 10;
}

Person p = new Person();
System.out.println(p);
// Output: Person@4a574795 😕

The Solution: Override toString!

We teach our object to introduce itself properly:

class Person {
    String name = "Alice";
    int age = 10;

    @Override
    public String toString() {
        return "Hi! I'm " + name +
               ", " + age + " years old!";
    }
}

Person p = new Person();
System.out.println(p);
// Output: Hi! I'm Alice, 10 years old! 😊

🎯 Key Points

🔍 The equals Method: Finding Your Twin

The Problem: Identity Crisis!

Imagine two kids with the same name, same age, same everything. Are they the same person? No! But are they equal? That depends on what “equal” means to you!

Person alice1 = new Person("Alice", 10);
Person alice2 = new Person("Alice", 10);

// Using == checks if they're the SAME object
System.out.println(alice1 == alice2);
// false - different objects in memory!

// Default equals() also checks identity
System.out.println(alice1.equals(alice2));
// false - same as ==

The Solution: Define What “Equal” Means!

class Person {
    String name;
    int age;

    @Override
    public boolean equals(Object obj) {
        // Same object? Definitely equal!
        if (this == obj) return true;

        // Null or different class? Not equal!
        if (obj == null) return false;
        if (getClass() != obj.getClass())
            return false;

        // Compare the important stuff
        Person other = (Person) obj;
        return this.age == other.age &&
               this.name.equals(other.name);
    }
}

Now:

System.out.println(alice1.equals(alice2));
// true! They have same name and age!

📋 The 5 Rules of equals()

🔢 The hashCode Method: Your Object’s ID Number

What’s a Hash Code?

Think of a hash code like a locker number at school. Every student gets a number, and students with the same characteristics might share a locker.

Person alice = new Person("Alice", 10);
System.out.println(alice.hashCode());
// Output: 1234567 (some number)

Why Do We Need It?

Hash codes help Java find objects SUPER FAST in collections like HashMap and HashSet.

Analogy:

• Without hash codes: Check EVERY locker to find Alice 🐌
• With hash codes: Go directly to locker #1234567 🚀

The Override

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + age;
    result = 31 * result +
             (name != null ? name.hashCode() : 0);
    return result;
}

Or use the easy way:

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

🤝 The Sacred Contract: equals() and hashCode()

THE GOLDEN RULE 🌟

If two objects are equal, they MUST have the same hash code!

graph TD
    A["Object A equals Object B?"]
    A -->|Yes| B["Hash codes MUST be same"]
    A -->|No| C["Hash codes CAN be different"]
    style B fill:#90EE90,stroke:#333

What Happens If You Break the Rule?

// BAD: equals() overridden, hashCode() not!
class Person {
    String name;

    @Override
    public boolean equals(Object obj) {
        // ... proper equals
    }
    // hashCode() NOT overridden - DANGER!
}

Set<Person> people = new HashSet<>();
Person p1 = new Person("Alice");
people.add(p1);

Person p2 = new Person("Alice");
System.out.println(p1.equals(p2)); // true
System.out.println(people.contains(p2));
// false! 😱 HashSet can't find it!

✅ The Contract Summary

📋 The clone Method: Making Copies

The Idea

Sometimes you want an exact copy of an object. Like photocopying a drawing!

class Sheep implements Cloneable {
    String name;

    public Sheep(String name) {
        this.name = name;
    }

    @Override
    protected Object clone()
            throws CloneNotSupportedException {
        return super.clone();
    }
}

Sheep dolly = new Sheep("Dolly");
Sheep dollyClone = (Sheep) dolly.clone();

System.out.println(dollyClone.name); // Dolly
System.out.println(dolly == dollyClone); // false
// Two different sheep, same name!

🔑 Two Requirements for Cloning

1. Implement Cloneable interface (like a permission slip)
2. Override the clone() method

Without Cloneable, you get a CloneNotSupportedException!

🌊 Shallow vs Deep Copy: The Photo Album Problem

Shallow Copy: Just the Surface

Imagine copying a photo album. A shallow copy copies the album cover… but keeps pointing to the SAME photos inside!

class Album implements Cloneable {
    String name;
    Photo[] photos;  // Array of Photo objects

    @Override
    protected Object clone()
            throws CloneNotSupportedException {
        return super.clone(); // Shallow!
    }
}

Album original = new Album();
Album copy = (Album) original.clone();

// DANGER: Both share the SAME photos array!
copy.photos[0] = new Photo("Beach");
// original.photos[0] is ALSO changed! 😱

graph LR
    A["Original Album"] --> P["Photos Array"]
    B["Shallow Copy"] --> P
    style P fill:#FF6B6B,stroke:#333

Deep Copy: True Independence

A deep copy copies EVERYTHING — the album AND all the photos inside!

@Override
protected Object clone()
        throws CloneNotSupportedException {
    Album cloned = (Album) super.clone();

    // Create NEW array with copies of photos
    cloned.photos = new Photo[photos.length];
    for (int i = 0; i < photos.length; i++) {
        cloned.photos[i] =
            (Photo) photos[i].clone();
    }
    return cloned;
}

graph LR
    A["Original Album"] --> P1["Original Photos"]
    B["Deep Copy"] --> P2["Copied Photos"]
    style P1 fill:#90EE90,stroke:#333
    style P2 fill:#87CEEB,stroke:#333

Quick Comparison

🛡️ Defensive Copying: Protecting Your Treasures

The Problem: Unwanted Changes

When someone gives you an object, they might change it later — and YOUR copy changes too!

class BankAccount {
    private Date createdDate;

    // DANGEROUS constructor!
    public BankAccount(Date date) {
        this.createdDate = date; // Same reference!
    }

    // DANGEROUS getter!
    public Date getCreatedDate() {
        return createdDate; // Exposes internal state!
    }
}

Date myDate = new Date();
BankAccount account = new BankAccount(myDate);

// Attacker changes the date!
myDate.setYear(1900);
// account.createdDate is ALSO 1900! 😱

The Solution: Defensive Copies

Copy on the way IN and copy on the way OUT!

class BankAccount {
    private Date createdDate;

    // SAFE constructor - copy on entry
    public BankAccount(Date date) {
        this.createdDate = new Date(date.getTime());
    }

    // SAFE getter - copy on exit
    public Date getCreatedDate() {
        return new Date(createdDate.getTime());
    }
}

Now:

Date myDate = new Date();
BankAccount account = new BankAccount(myDate);

myDate.setYear(1900);
// account.createdDate is SAFE! 🛡️
// Still has the original date!

🎯 When to Use Defensive Copying

The Golden Rule of Defensive Copying

Never let outsiders hold references to your internal mutable objects!

🎉 Summary: Your Object Class Toolkit

You’ve learned the 7 superpowers every Java object inherits:

graph TD
    O["Object Class Methods"] --> T["toString - Describe"]
    O --> E["equals - Compare"]
    O --> H["hashCode - Identify"]
    O --> C["clone - Copy"]
    E -.-> H
    C --> S["Shallow Copy"]
    C --> D["Deep Copy"]
    D --> DC["Defensive Copying"]
    style O fill:#FFD700,stroke:#333

💡 Pro Tips to Remember

1. Always override hashCode() when you override equals()
2. Use Objects.hash() for easy hash code generation
3. Consider using copy constructors instead of clone()
4. Defensive copy all mutable objects at boundaries
5. Test your equals() for symmetry, transitivity, and consistency

You’re now ready to create objects that know who they are, can find their twins, and protect their secrets! 🚀