Classes in OOP , methods and attributes memory internals [closed]

The relevant terms here are dynamic and static typing.

With static typing, all the types are fixed and do not change during the execution time of your program. This is what traditional languages like C/Java/etc are doing. The advantage for compiled languages with static typing is that they know, that each object of your class will have the same methods, and as such they are free to optimize with that in mind. In particular, each method implementation is only stored once in memory and merely the object attributes are stored per individual object. For an object, you just need to store a single pointer to its class' method table.

On the other hand, languages like Python offer dynamic typing, where a type can change during runtime. For example, in Python it is possible to add a method to a class. Once you start modifying the type though, you are no longer guaranteed, that a once compiled version of your method(s) is still valid, so it's more troublesome to store these methods. If your language even allows you to add methods to an object's class per individual object, than no two objects can share their type.

There are still a lot of optimizations possible with dynamic typing, but as a rule of thumb, statically typed languages have a much easier time for optimizing, because they have a lot of guarantees regarding their type system. On the other hand, the programmer is forced to adhere to the type system just as well, in contrast to the freedom of a dynamically typed language. Both sides have advantages and disadvantages, but these are outside of the scope of your question.

OOP concepts do not change if you compare them in different programming languages though the way it gets implemented might vary. I have been working on C++ for 2 years and before that I learnt and worked in Java as well.

Here is how you can look at it.

Classes are the blueprints based on which objects are generated. In other words class can be seen as generic logical entities and objects are physical entity. For example: shape is a generic logical entity and circle is a physical entity.

Every class contains data and methods(function) to manipulate that data. for ex: shape has length, size etc as data and volume(), Area() etc as methods.

Now as far as I understood your question you are asking about how or when methods get differ for different object/instances. (correct me).

Now to answer that we need to understand Polymorphism which is an OOPs concept. Polymorphism has two variants static and dynamic. Static polymorphism is implemented through function/method overloading and Dynamic polymorphism is implemented through function/method overriding.

Static binding: Multiple methods, same name, same scope, different parameters. Gets resolved at compile time.

Dynamic binding: Multiple methods, same name, different scope, same parameters. Gets resolved at runtime.

Now if two instances(say O1 O2) work in such a way that they eventually call different methods either through static binding or dynamic binding. That means instance O1 will call different methods when you compare it with O2.

I hope that makes some sense, post doubts if any.

Even in languages that allow dynamic modification of a single instance, like Python or Ruby, the code of methods still only exists in memory once. The main difference between those languages and those where a single instance cannot be changed (like Java or C++) is that in the static languages, each instance conceptually holds a single reference to a list of supported functions that is shared between all instances (in concrete implementations this is often called the vtable), whereas in dynamic languages each instance needs its own table. (As an optimization, unmodified instances could share the table and only create their own versions when they get modified.)

In either case, however, those tables will contain references to the code of the actual methods, and that code will be shared. Unless your language is so dynamic that it can modify the actual code at runtime.