🚗 Can a Class Implement Two Interfaces with the Same Method?

Yes — a class can implement multiple interfaces that define methods with the same signature.

Let’s understand how it works:

Suppose we have two interfaces:

• Car — defines a go() method and a stop() method.

• Driverless — defines a sitDownAndRelax() method and also a go() method (same signature as in Car).

Now, if a class Honda implements both interfaces, there’s no conflict.
This is because both interfaces only declare methods — they don’t provide implementations.

The Honda class simply needs to override and implement the go() method once, satisfying both interfaces simultaneously.

interface Car {
    void go();
    void stop();
}

interface Driverless {
    void go();
    void sitDownAndRelax();
}

class Honda implements Car, Driverless {
    @Override
    public void go() {
        System.out.println("Honda is moving...");
    }

    @Override
    public void stop() {
        System.out.println("Honda has stopped.");
    }

    @Override
    public void sitDownAndRelax() {
        System.out.println("Sit back and relax, Honda is driving itself!");
    }
}

When we run this code, everything works perfectly fine — there’s no ambiguity and no diamond problem, because:

• Both interfaces only declare the method (no implementation).

• The implementing class provides a single concrete implementation, which fulfills both contracts.

---

✅ Conclusion:
Yes, a class in Java can implement two interfaces with methods that have the same signature.
Unlike multiple class inheritance, this doesn’t cause conflicts because interfaces don’t define behavior — they only define contracts.

🧩 What Are the Methods of the Object Class in Java?

In Java, the Object class is the root class of the entire class hierarchy — every class in Java implicitly inherits from it.
This means all classes have access to several important methods defined in Object.

---

🧠 Common Methods Inherited from the Object Class

1. equals(Object obj) – Used to compare two objects for equality.
   By default, it compares memory addresses, but it can be overridden to compare object content.

2. hashCode() – Returns an integer hash code for the object.
   Often overridden along with equals() to maintain consistency when using objects in hash-based collections like HashMap or HashSet.

3. toString() – Returns a string representation of the object.
   Commonly overridden to provide meaningful output (e.g., printing object data instead of memory reference).

4. clone() – Creates and returns a copy (clone) of the object.
   A class must implement the Cloneable interface to use this method.

5. finalize() – Called by the garbage collector before an object is destroyed.
   (However, this method is deprecated in modern Java versions.)

---

⚙️ Other Important Methods

• wait(), notify(), and notifyAll() — These methods are also defined in the Object class but are mainly used for thread synchronization in multithreading.
  They cannot be overridden, but they can be used by any class to coordinate threads.

---

✍️ Summary

• Methods like equals(), hashCode(), toString(), clone(), and finalize() can be overridden to customize object behavior.

• Methods like wait(), notify(), and notifyAll() are used for inter-thread communication, not for overriding.

---

✅ In short:
Every class in Java inherits useful methods from Object, which form the foundation for comparison, cloning, debugging, and thread coordination.

🔢 What Is the Default hashCode() Implementation in Java?

If a class does not override the hashCode() method, the implementation provided by the Object class is used.

By default, the hashCode() method in the Object class returns an integer value that represents the memory address of the object — or more precisely, a value derived from the object’s internal memory reference.

This means:

• Each unique object in memory will generally have a different hash code value.

• If two references point to the same object, they will return the same hash code.

• However, two different objects (even with identical data) will have different hash codes, unless the method is overridden.

---

🧠 Example

class Demo {}

public class HashCodeExample {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();

        System.out.println(d1.hashCode()); // e.g., 460141958
        System.out.println(d2.hashCode()); // e.g., 1163157884
    }
}

Each object returns a unique value because the default hashCode() implementation is based on the object’s memory location.

---

✅ In short:
If you don’t override hashCode(), the default implementation returns a number derived from the object’s memory address — ensuring each object instance typically has a unique hash code.