Why does every object in Java implicitly extend java.lang.Object class?
Solution 1
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
Solution 2
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.
Solution 3
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 Collection
s, etc. possible.
See also on discussions on reference and primitive types.
Solution 4
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
.
Solution 5
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.
codeMan
Enthusiastic software developer. Working as Staff engineer at Blackhawk Networks
Updated on July 18, 2022Comments
-
codeMan almost 2 years
I have been programming in Java for quite some time, but when I tried to explain what an
java.lang.Object
class is to a friend, I could not come up with more than a simple one-liner:All objects in Java extend
java.lang.Object
implicitlyI was not quite sure why it should do so.
So, I looked upon the source code on GrepCode, hoping that I can find some clues. Now I know what a
java.lang.Object
is and what it does, I want to know if there was any specific reason as to why it was designed this way.My question still prevails: why should every object extend
java.lang.Object
? -
Adam over 10 yearsYes, but OP asks why
-
supercat over 10 yearsArguably,
clone
should have belonged to a "magical"CloneableObject
base class, andfinalize
should have been replaced with a "register for cleanup notification" method. Having universal functions to find out an object's class, though, and define an equivalence relation is helpful [the latter would be even more helpful if objects had separate pairs of equals/hashCode methods which consistently define the two universal equivalence relations, rather than using one pair of methods but being inconsistent about which relation it implements]. -
user207421 over 9 yearsDoesn't say why. Not that it's a real question.
-
Vishnu Prasad Kallummel about 3 yearsI also believe that the extension of Object class by default enforces that the 'Multiple Inheritance' is not possible.