Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

send a "message" to o that invokes one of o's methods, for example, for o to print
a description of itself, for o to convert itself to a string, or for o to return the value
of one of its data fields. The secondary way that p can interact with o is for p to
access one of o's fields directly, but only if o has given other objects like p
permission to do so. For example, an instance of the Java class Integer stores,
as an instance variable, an integer, and it provides several operations for accessing
this data, including methods for converting it into other number types, for
converting it to a string of digits, and for converting strings of digits to a number.
It does not allow for direct access of its instance variable, however, for such
details are hidden.
Dynamic Dispatch
When a program wishes to invoke a certain method a() of some object o, it
sends a message to o, which is usually denoted, using the dot-operator syntax
(Section 1.3.2), as "o.a()." In the compiled version of this program, the code
corresponding to this invocation directs the run-time environment to examine o's
class T to determine if the class T supports an a() method, and, if so, to execute
it. Specifically, the run-time environment examines the class T to see if it defines
an a() method itself. If it does, then this method is executed. If T does not define
an a() method, then the run-time environment examines the superclass S of T. If
S defines a(), then this method is executed. If S does not define a(), on the
other hand, then the run-time environment repeats the search at the superclass of
S. This search continues up the hierarchy of classes until it either finds an a()
method, which is then executed, or it reaches a topmost class (for example, the
Object class in Java) without an a() method, which generates a run-time error.
The algorithm that processes the message o.a() to find the specific method to
invoke is called the dynamic dispatch (or dynamic binding) algorithm, which
provides an effective mechanism for locating reused software. It also allows for
another powerful technique of object-oriented programming—polymorphism.
2.2.2 Polymorphism
Literally, "polymorphism" means "many forms." In the context of object-oriented
design, it refers to the ability of an object variable to take different forms. Objectoriented
languages, such as Java, address objects using reference variables. The
reference variable o must define which class of objects it is allowed to refer to, in
terms of some class S. But this implies that o can also refer to any object belonging
to a class T that extends S. Now consider what happens if S defines an a() method
and T also defines an a() method. The dynamic dispatch algorithm for method
invocation always starts its search from the most restrictive class that applies. When
o refers to an object from class T, then it will use T's a() method when asked for
o.a(), not S's. In this case, T is said to override method a() from S. Alternatively,
when o refers to an object from class S (that is not also a T object), it will execute
98