Understanding Object Class Methods in Java: Common Methods and Their Applications

Java is a high-level, object-oriented programming language that is widely used for building robust and scalable software applications. In Java, every class, including custom ones, extends from the Object class by default. This means that every object in Java has a set of predefined methods that are common to all objects. These methods are provided by the Object class and are used to manipulate or retrieve information about the objects. In this article, we will explore some of the essential methods available in the Object class and how they can be used in day-to-day programming.

The Object Class and its Methods

The Object class in Java is the superclass of all classes. When you define a new class, it automatically extends the Object class unless you explicitly specify a different superclass. This class provides a number of methods that are common to all objects:

toString Method

The toString method in the Object class is a commonly used method that returns a string representation of the object. This string can be useful for debugging and logging purposes. When overridden in a subclass, the toString method can provide a more meaningful and detailed representation of the object based on the specific needs of the class. Here's an example of how you can use it:

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
          name;
          age;
    }
    @Override
    public String toString() {
        return Person [name   name   , age   age   ];
    }
}
Person person  new Person(John Doe, 30);
(()); // Output: Person [nameJohn Doe, age30]

equals Method

The equals method in the Object class is used to compare two objects for equality. By default, the equals method compares the references of the objects, not their content. To compare the content, you should override the equals method in your custom classes. If you need to check if two objects are equal based on their content, you can do something like this:

public class Employee {
    private String id;
    private String name;
    public Employee(String id, String name) {
          id;
          name;
    }
    @Override
    public boolean equals(Object obj) {
        if (this  obj) {
            return true;
        }
        if (obj  null || getClass() ! ()) {
            return false;
        }
        Employee other  (Employee) obj;
        return Objects.equals(id, )  Objects.equals(name, );
    }
}
Employee emp1  new Employee(12345, John);
Employee emp2  new Employee(12345, John);
(emp1.equals(emp2)); // Output: true

hashCode Method

The hashCode method is used by Java collections like HashMap and HashSet to determine the bucket where the object should be placed. It returns an integer hash code value that is used to index the object in the collections. By default, the hashCode method returns the result of the method, which returns the same hash code for an object as the default hashCode method in the Object class. If you want to customize the behavior, you should override the hashCode method in your custom classes. Here's an example:

public class Employee {
    private String id;
    private String name;
    public Employee(String id, String name) {
          id;
          name;
    }
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}
Employee emp1  new Employee(12345, John);
Employee emp2  new Employee(12345, John);
(emp1.hashCode()); // Output: 1176334552
(emp2.hashCode()); // Output: 1176334552

getClass Method

The getClass method in the Object class returns the runtime class object of the object on which it is called. This can be useful in scenarios where you need to determine the runtime type of an object. For example, if you have a generic method that can accept different types of objects, you can use the getClass method to check the type at runtime:

public void printType(Object obj) {
    Class? clazz  ();
    (Type of the object is:    ());
}
Employee emp  new Employee(12345, John);
printType(emp); // Output: Type of the object is: com.example.Employee

Clone Method

The clone method in the Object class creates and returns a copy of the object. However, by default, this method is not implemented and will cause a CloneNotSupportedException to be thrown. In order to use the clone method, you need to explicitly implement it in your custom classes. Here's an example of how to do it:

public class Employee implements Cloneable {
    private String id;
    private String name;
    public Employee(String id, String name) {
          id;
          name;
    }
    @Override
    public Object clone() {
        try {
            return ();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
Employee emp  new Employee(12345, John);
Employee cloneEmp  (Employee) ();
(cloneEmp.equals(emp)); // Output: true

notify and notifyAll Methods

The notify and notifyAll methods are used in conjunction with the wait method to manage threads in Java. These methods are part of the Object class and are used to wake up threads that are waiting for a specific condition. By default, these methods do not do anything; to use them, you need to override the synchronized methods in your custom classes. Here's a simple example:

public class NotificationExample {
    private int flag  0;
    public synchronized void waitMethod(int flag) throws InterruptedException {
        while (this.flag ! flag) {
            this.wait();
        }
        (Condition met, notify all.);
        ();
    }
    public synchronized void setFlag(int flag) {
        this.flag  flag;
        (Flag set to:    flag);
        ();
    }
}
NotificationExample example  new NotificationExample();
new Thread(() - {
    try {
        example.waitMethod(1);
    } catch (InterruptedException e) {
        ();
    }
}).start();
(1); // Output: Flag set to: 1
 // Thread might be sleeping
try {
    (1000);
} catch (InterruptedException e) {
    ();
}
new Thread(() - {
    try {
        example.waitMethod(2);
    } catch (InterruptedException e) {
        ();
    }
}).start();
(2); // Output: Flag set to: 2

wait Method

The wait method is used to make a thread wait until it is notified by another thread. When a thread calls the wait method, it releases the monitor lock and goes to wait for a notification or a specific timeout. Here's an example of how you can use the wait method:

public class WaitExample {
    private int counter  0;
    public synchronized void increment() {
        counter  ;
        (Counter incremented to:    counter);
        try {
            (2000);
        } catch (InterruptedException e) {
            ();
        }
    }
    public synchronized void decrement() {
        while (counter ! 0) {
            counter--;
            (Counter decremented to:    counter);
            try {
                this.wait();
            } catch (InterruptedException e) {
                ();
            }
        }
    }
}
WaitExample example  new WaitExample();
new Thread(() - {
    ();
}).start();
new Thread(() - {
    ();
}).start();

These methods are fundamental to understanding and working with objects in Java. By mastering their usage, you can write more efficient and robust code. If you have any questions or need further clarification, feel free to leave a comment below.