The java.lang.Object class serves as the root of the entire Java class hierarchy. Every user-defined class, as well as built-in classes, inherits directly or indirectly from this base class. Because it is the ultimate ancestor, the methods defined within Object are available to all Java objects.

Key Methods in the Object Class

The following methods provide fundamental behaviors that are frequently overridden in custom development:

Understanding Object Cloning

Cloning is the process of creating a duplicate instance of an existing object. In Java, this is categorized into two types:

1. Shallow Copy: This is the default behavior. It copies all field values. For primitive types, the values are duplicated; however, for rfeerence types, only the reference (memory address) is copied, meaning both the original and the clone share the same nested objects.
2. Deep Copy: This requires manual implementation or third-party tools. It creates new instances for all internal reference types, ensruing that the clone and the original are completely independent.

Implementation Example

To enable cloning, a class must implement the Cloneable marker interface and override the clone() method. Without the interface, calling clone() results in a CloneNotSupportedException.

class Account implements Cloneable {
    private String id;
    private double balance;

    public Account(String id, double balance) {
        this.id = id;
        this.balance = balance;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Account account = (Account) o;
        return Double.compare(account.balance, balance) == 0 && id.equals(account.id);
    }

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

public class ObjectTester {
    public static void main(String[] args) throws CloneNotSupportedException {
        Account acc1 = new Account("A001", 5000.0);
        
        // Using toString()
        System.out.println("Account Info: " + acc1.toString());

        // Using clone()
        Account acc2 = (Account) acc1.clone();
        
        // Using equals()
        System.out.println("Objects equal: " + acc1.equals(acc2));
        System.out.println("Same reference: " + (acc1 == acc2));
    }
}

The Objects Utility Class

The java.util.Objects class provides static helper methods to perform operations on objects safely, particularly concerning null pointers.

Null-Safe Operations

Using the Objects utility class prevents common NullPointerException errors during comparison or validation.

import java.util.Objects;

public class UtilityExample {
    public static void main(String[] args) {
        String text1 = "Hello";
        String text2 = null;

        // Objects.equals() handles the null check internally
        boolean check = Objects.equals(text1, text2);
        System.out.println("Comparison Result: " + check);

        // Validation checks
        System.out.println("Is text2 null? " + Objects.isNull(text2));
        System.out.println("Is text1 present? " + Objects.nonNull(text1));
    }
}