Programming has the two well-known paradigms, Object-Oriented Programming, and Procedural Programming.
So, what Object concept being developed to, through OOP, is to be the root of everything that has a value to be stored in the memory, So as long as you are defining an object from (Class, Variable, Enum, …etc), then you are creating an “Object”.
Why it goes through that?
Root Of Everything
In OOP, every data or value to be stored in memory, it has to get an address and to get that address it must be defined as a root to “Object”, which means it can be casted to Object.
Well, “Object” in OOP, has nothing to do but storing an address in the memory, So if you are defining a “String”, then its root came from “Object”, Which means you have a reference for your variable in the memory 🙂 (Expected Concept).
How does that work with classes?
Classes have objects, variables, and functions inside, where all of these inner objects have addresses, which make things more complicated for the compiler, but it’s already an advantage.
The advantage is, when you have many operations are being done to an Object, then that object ( Will Be Stored Again But With Another Address Of The Updated Object After Operations Are Applied To ).
So, the object keeps dynamically scaling, getting linked to objects and unlinked to others.
As we are able to link/unlink objects to each other through ( Referencing Concept), this will lead to the ability to traverse between the linked objects, making paths from an object ending to another, e.g. (Object.secondObject.thirdObject … etc).
This will lead to a dynamic lifetime execution, where the objects are being called, unlinked (deleted for certain time), and linked to other objects, separating the execution of different parts of the program, and execute them in certain situations.
Finally, the object concept is very strong in making complex systems, with multiple internal structures, and with dynamic execution behaviors.