Difference between Dynamic binding and message passing in oop?

Answer 1

Message to method binding

A question of whether a message should bind to

• a method in the class to which the reference variable pointing to the receiver was declared to be an instance of (static binding), or
• a method in the class to which the receiver is an instance of at run-time (dynamic binding).

Dynamic binding

• in the context of OOP typically refers to the binding of methods to messages
• methods varying dynamically entails much of the power of the OO approach
• main source of power in an OO language
• search for method (code body) to bind to a message starts from the class to which the receiver currently (i.e., at run-time) is an instance of, and and proceeds up the class inheritance hierarchy from there (static binding initiates the search from the class to which the reference variable pointing to the receiver was declared to be an instance of)
• if no method found anywhere, a run-time error (method not found) is reported and this is typically the only error in a Smalltalk program ever detected and reported
• example: Mammal m; Cow c; if (user input) m = new Cow; // if static binding used, run method in class Mammal bound to run message here // if dynamic binding used, run method in class Cow bound to run message here m.run else c = new Cow; c.run

Why dynamic binding?

• `to allow software systems to be more easily extended during both development and maintenance' [COPL] p. 461
• allows dynamic polymorphism, consider sorting (written in a general way)
• obviates need for abstract classes (e.g., Fruit class, peel method)
• while other forms of dynamism in languages tend to be compromise efficiency in the run-time system, dynamic binding involves little overhead

Dynamic vs. static binding

• advantages of each?
• disadvantages of each?

Message to method binding in languages

• Smalltalk
  • dynamic by default
  • by sending a message to super we can initiate the search (for the method to bind to the message) in the parent class of the class to which the sender belongs (i.e., like sending a message to self with a different entry point for the search (not quite static binding))
• Java and Eiffel
  • dynamic by default
  • in Java, preface method with final qualifier to prevent any subclass from overriding it
  • in Eiffel, preface method with frozen qualifier to prevent any subclass from overriding it
• C++
  • static by default (why?)
  • preface method with virtual qualifier for dynamic binding; the search for the method to bind to the message starts in the class which defines the method prefaced with the virtual qualifier and proceeds down the inheritance hierarchy from there to the class to which the receiver object belongs
• Objective-C, Modula-3, Python, and Ruby use dynamic binding for all methods
• Simula, C# and Ada 95 use static binding by default and support dynamic binding as an option

Dynamic binding ambiguity

Do not confuse dynamic binding of messages to methods with dynamic allocation and deallocations of objects.

• Smalltalk: manual dynamic allocation, automatic deallocation
• Java: manual dynamic allocation, automatic deallocation
• C++: manual dynamic allocation, manual deallocation

Answer 2

Message passing is simply the technical term for invoking a non-static class method, a function that is bound to an instance of a class (an object), using that method to pass information to the object through formal parameters (function arguments). In order for the compiler to know upon which object it should operate, the programmer must specify the object by a named variable or reference (an alias), followed by the member-of-object operator (.) followed by the function name and its arguments. The programmer can also pass messages to an anonymous object via a named pointer to the object followed by the member-of-pointer operator (->) followed by the function name and its arguments. In addition to the user-specified arguments, the compiler uses the named object or pointer to pass a hidden parameter to the function (the this pointer), so the function implicitly knows upon which instance it should operate.

Dynamic binding cannot really be compared with message passing since dynamic binding is really part of the same mechanism, as is static binding. When invoking a non-virtual class method, the compiler can statically bind to that function's address. However, when invoking a virtual method, the compiler can only statically bind to the most-derived override of that method if that override is both visible to the compiler (is defined by the object itself or by one of its base classes) and is explicitly declared final. If not, the compiler cannot know in advance which override is the most-derived method and must dynamically bind to it instead. That is, the compiler injects code to perform a vtable (virtual function table) lookup which will be performed at runtime. In so doing, the object behaves polymorphically according to its actual runtime type. This also permits the exact same code to work with derivatives created in the future -- derivatives and overrides for which the calling code cannot possibly know exist in advance. In other words, dynamic binding allows messages to be passed to objects for which no classes currently exist, so long as those new classes are derived from base classes with a virtual interface that the compiler (and the calling code) does know about.

Answer 3

what is the difference between message passing and dynamic binding

Answer 4

difference between inheritaens & pholimorephezem in java