Object Class in Java

Introduction to Object Class in Java

The Object Class in Java is the root class from which every other class in Java inherits. It is part of the java.lang package and provides a set of fundamental methods that are universally available for all Java objects. Understanding the Object class is essential for Java developers because it forms the base of Java’s class hierarchy.

What is the Object Class?

The Object class is a superclass of all classes in Java. Whether you create a custom class or use built-in Java classes, they all implicitly inherit from the Object class if no other superclass is specified.

Key characteristics of the Object class:

• Defined in java.lang package
• Root of Java class hierarchy
• Provides essential methods for object manipulation
• Supports core concepts like equality, cloning, and string representation

Core Methods of the Object Class in Java

The Object class provides several important methods that every Java object inherits. Understanding these methods is crucial for practical Java programming.

1. equals() Method

Used to compare two objects for equality. By default, it compares object references, but it can be overridden to compare object content.

📄

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        Person p2 = new Person("Alice", 25);
        System.out.println(p1.equals(p2)); // Output: true
    }
}

2. hashCode() Method

Returns an integer representation of the object, usually used in hash-based collections like HashMap or HashSet.

3. toString() Method

Returns a string representation of the object. By default, it returns the class name followed by the object’s hashcode. It is commonly overridden to provide meaningful output.

📄

class Car {
    String model;
    int year;

    Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    @Override
    public String toString() {
        return "Car{model='" + model + "', year=" + year + "}";
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", 2022);
        System.out.println(car); // Output: Car{model='Toyota', year=2022}
    }
}

Object Class in Java

The Object class is widely used in practical programming scenarios, such as:

• Creating custom objects with equality checks using equals() and hashCode()
• Using objects as keys in HashMap and HashSet
• Logging object information with toString()
• Cloning objects for safe data handling in multithreaded applications

Practical Example: Using Object Class Methods

📄

import java.util.HashSet;

class Student {
    String name;
    int rollNo;

    Student(String name, int rollNo) {
        this.name = name;
        this.rollNo = rollNo;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return rollNo == student.rollNo && name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode() + rollNo;
    }

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

public class Main {
    public static void main(String[] args) {
        HashSet students = new HashSet<>();
        students.add(new Student("John", 101));
        students.add(new Student("John", 101)); // Duplicate, won't be added
        System.out.println(students);
    }
}

Understanding hashCode() Method in Java

The hashCode() method in Java is one of the core methods inherited from the Object class. It returns an integer value, called the hash code, that represents the object in memory. The hashCode() method is widely used in collections that rely on hashing, such as HashMap, HashSet, and Hashtable.

Key Points About hashCode()

• It returns an integer value unique to the object (though collisions can occur).
• Objects that are equal (via equals()) must return the same hash code.
• It is used internally by hash-based collections to organize and access objects efficiently.
• By default, hashCode() generates a value based on the object's memory address, but it can be overridden to use object fields.

Why hashCode() is Important

The hashCode() method is essential for performance in collections. For example, when you store objects in a HashMap, Java uses the hash code to determine the bucket in which to place the object. A properly implemented hashCode() improves retrieval efficiency.

Example of Overriding hashCode()

📄

class Employee {
    String name;
    int id;

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

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Employee employee = (Employee) obj;
        return id == employee.id && name.equals(employee.name);
    }

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + id;
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee("John", 101);
        Employee e2 = new Employee("John", 101);

        System.out.println("e1 hashCode: " + e1.hashCode());
        System.out.println("e2 hashCode: " + e2.hashCode());
        System.out.println("e1 equals e2? " + e1.equals(e2));
    }
}

Explanation

 Use Case of hashCode()

Consider a system that tracks users. If you store user objects in a HashSet, the hashCode() method ensures that duplicate users are not added, even if you create a new object instance with the same data:

📄

HashSet employees = new HashSet<>();
employees.add(new Employee("John", 101));
employees.add(new Employee("John", 101)); // Duplicate won't be added
System.out.println(employees.size()); // Output: 1

Summary Table for hashCode()

Key Takeaways

• Always override hashCode() when overriding equals().
• Objects that are equal must have the same hash code to work correctly in hash-based collections.
• Proper implementation of hashCode() improves performance in collections.

Object Class Methods Summary Table

The Object class in Java is the foundation of Java’s object-oriented programming model. Mastering its methods such as equals(), hashCode(), and toString() is essential for effective Java programming. Understanding the Object class helps developers write cleaner, reusable, and maintainable code while leveraging Java’s built-in features like hashing, cloning, and logging.

FAQs 

1. Why is Object class important in Java?

The Object class is important because it is the root of all classes in Java. It provides basic methods like equals(), hashCode(), and toString() that every Java object inherits, making it essential for code consistency and reuse.

2. Can we create an instance of Object class directly?

Yes, we can create an instance of the Object class directly using new Object(). However, in most cases, we work with subclasses that inherit from Object.

3. How do we override the equals() method correctly?

To override equals() correctly, ensure:

• Check for reference equality first
• Check if the object is of the same class
• Compare the actual content of the objects

4. What is the difference between hashCode() and equals()?

5. Is finalize() method still recommended in Java?

No, finalize() is deprecated in modern Java. It was used for cleanup before garbage collection but is unreliable. Developers should use try-with-resources or AutoCloseable for resource management.