Let’s consider several additional examples of polymorphism.
If class Rectangle
is derived from class Quadrilateral
(a four-sided shape), then a Rectangle
is a more specific version of a Quadrilateral
. Any operation (e.g., calculating the perimeter or the area) that can be performed on a Quadrilateral
object also can be performed on a Rectangle
object. These operations also can be performed on other Quadrilateral
s, such as Square
s, Parallelogram
s and Trapezoid
s. The polymorphism occurs when an app invokes a method through a base-class variable—at execution time, the correct derived-class version of the method is called, based on the type of the referenced object. You’ll see a simple code example that illustrates this process in Section 12.3.
As another example, suppose we design a video game that manipulates objects of many different types, including objects of classes Martian
, Venusian
, Plutonian
, SpaceShip
and LaserBeam
. Imagine that each class inherits from the common base class SpaceObject
, which contains method Draw
. Each derived class implements this method. A screen-manager app maintains a collection (e.g., a SpaceObject
array) of references to objects of the various classes. To refresh the screen, the screen manager periodically sends each object the same message—namely, Draw
. However, each object responds in a unique way. For example, a Martian
object might draw itself in red with the appropriate number of antennae. A SpaceShip
object might draw itself as a bright silver flying saucer. A LaserBeam
object might draw itself as a bright red beam across the screen. Again, the same message (in this case, Draw
) sent to a variety of objects has many forms of results.
A screen manager might use polymorphism to facilitate adding new classes to a system with minimal modifications to the system’s code. Suppose we want to add Mercurian
objects to our video game. To do so, we must build a Mercurian
class that extends Space-Object
and provides its own Draw
method implementation. When objects of class Mercurian
appear in the SpaceObject
collection, the screen-manager code invokes method Draw
, exactly as it does for every other object in the collection, regardless of its type, so the new Mercurian
objects simply “plug right in” without any modification of the screen-manager code by the programmer. Thus, without modifying the system (other than to build new classes and modify the code that creates new objects), you can use polymorphism to include additional types that might not have been envisioned when the system was created.
Polymorphism promotes extensibility: Software that invokes polymorphic behavior is independent of the object types to which messages are sent. New object types that can respond to existing method calls can be incorporated into a system without requiring modification of the polymorphic system logic. Only client code that instantiates new objects must be modified to accommodate new types.