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

S's a() method when asked for o.a(). Polymorphism such as this is useful
because the caller of o.a() does not have to know whether the object o refers to an
instance of T or S in order to get the a() method to execute correctly. Thus, the
object variable o can be polymorphic, or take many forms, depending on the
specific class of the objects it is referring to. This kind of functionality allows a
specialized class T to extend a class S, inherit the standard methods from S, and
redefine other methods from S to account for specific properties of objects of T.
Some object-oriented languages, such as Java, also provide a useful technique
related to polymorphism, which is called method overloading. Overloading occurs
when a single class T has multiple methods with the same name, provided each one
has a different signature. The signature of a method is a combination of its name
and the type and number of arguments that are passed to it. Thus, even though
multiple methods in a class can have the same name, they can be distinguished by a
compiler, provided they have different signatures, that is, are different in actuality.
In languages that allow for method overloading, the run-time environment
determines which actual method to invoke for a specific method call by searching
up the class hierarchy to find the first method with a signature matching the method
being invoked. For example, suppose a class T, which defines a method a(),
extends a class U, which defines a method a(x,y). If an object o from class T
receives the message "o.a(x,y)," then it is U's version of method a that is invoked
(with the two parameters x and y). Thus, true polymorphism applies only to
methods that have the same signature, but are defined in different classes.
Inheritance, polymorphism, and method overloading support the development of
reusable software. We can define classes that inherit the standard instance variables
and methods and can then define new more-specific instance variables and methods
that deal with special aspects of objects of the new class.
2.2.3 Using Inheritance in Java
There are two primary ways of using inheritance of classes in Java, specialization
and extension.
Specialization
In using specialization we are specializing a general class to particular subclasses.
Such subclasses typically possess an "is a" relationship to their superclass. A
subclass then inherits all the methods of the superclass. For each inherited
method, if that method operates correctly independent of whether it is operating
for a specialization, no additional work is needed. If, on the other hand, a general
method of the superclass would not work correctly on the subclass, then we
should override the method to have the correct functionality for the subclass. For
example, we could have a general class, Dog, which has a method drink and a
method sniff. Specializing this class to a Bloodhound class would probably not
99