Why does every object in Java implicitly extend java.lang.Object class?

I would say that the reason is to have a common API for all objects in java to supports basic functionality like

• synchronization - wait, notify, notifyAll
• garbage collection - finalize
• collection support - hashCode, equals
• object cloning - clone

And every object

• has a class it belongs to - getClass
• can represent itself as a string, because we are humans and can read strings - toString

I think the most important use of Object is not to provide common methods like toString() but to provide a common type that would hold all reference types.

C++ don't have an Object equivalent and people are still happy. But since Java don't have pointers and C++-like templates, Object is required to make implementations of Collections, etc. possible.

See also on discussions on reference and primitive types.

This is how the language is designed. Every object will inherit from the base class Object. This means that it's guaranteed for every object there will be certain methods, like toString(), equals(), hashCode(), etc.

I would say Design. Common/Mandatory methods which every Object should support written there and extending that class as a language specification.

You find the reasons here in Official Docs.

If we are saying this is an Object ,They must have the common methods, Which defined/decided by API.

Imagine the below methods for every class on your Own.

protected Object clone() throws CloneNotSupportedException
      Creates and returns a copy of this object.


public boolean equals(Object obj)
      Indicates whether some other object is "equal to" this one.


protected void finalize() throws Throwable
      Called by the garbage collector on an object when garbage
      collection determines that there are no more references to the object


public final Class getClass()
      Returns the runtime class of an object.


public int hashCode()
      Returns a hash code value for the object.


public String toString()
      Returns a string representation of the object.

The notify, notifyAll, and wait methods of Object all play a part in synchronizing the activities of independently running threads in a program:

public final void notify()
public final void notifyAll()
public final void wait()
public final void wait(long timeout)
public final void wait(long timeout, int nanos) 

So to reduce the pain, created a common and standard API.

Every Class extends Object class implicitly so that they provide basic features which according to Java recommendation every class should have. Such as clone(), equals(), hashCode(), toString(), etc.

By implicitly, it means that if you are not extending any class then only compiler will implicitly extends Object class.But if class already extends other class then compiler will not extend Object class. For eg. Class A{ }

Class B extends A{ }

Here compiler will implicitly add extends Object class in class A declaration.

Class A extends Object{ }

Class B extends A{ }

As class A extends Object class so it will provide basic functionality of Object class such as equals(), toString(),etc. And since Class B extends class A which implicitly extends Class Object, so class B also provides all those features.

Thus by following this approach every class objects(variables) complies to features which every Java Object should have, without going for Multiple Inheritance (a class extending more than one class) which Java doesn't allows. This approach follows Multi-Level Inheritance.

This is done so as most of the basic functions like toString() etc would be automatically inherited and to your next question this is NOT multiple inheritence it is multilevel inheritence... In multiple inheritence single class is derived from 2 or more base class whereas in multilevel as you have said it has a base class which is itself derived from Object class

Quoting Head first Java 2nd edition:

Without a common superclass for everything in Java, there’d be no way for the developers of Java to create classes with methods that could take your custom types... types they never knew about when they wrote the ArrayList class.

Which essentially explains the need of a generic predefined class type in Java, which can be used to implement the different features provided by the language.

See the docs:

The Object class, in the java.lang package, sits at the top of the class hierarchy tree. Every class is a descendant, direct or indirect, of the Object class. Every class you use or write inherits the instance methods of Object. You need not use any of these methods, but, if you choose to do so, you may need to override them with code that is specific to your class.

The Object class simply defines the basic state that all objects must have - Like comparing it to other objects.

It's the parent class of everything. It simply provides kind of template to all the derived objects.

It's a java design decision. It puts to use the concept of inheritance and re-usabilty. This ensures that all classes have some basic methods like wait(), toString() etc.

Object class is the most super class of java programming, It has predefined methods according to types, you can use those methods. & you don't need to extends object class anymore & anywhere it's implicitly there

Every class in Java is a descendent (direct or indirect) of the Object class. The Object class defines the basic state and behavior that all objects must have, such as the ability to compare oneself to another object, to convert to a string, to wait on a condition variable, to notify other objects that a condition variable has changed, and to return the object's class.