Java How to Program Fourth Edition - DCC

Chapter 9 Object-Oriented Programming 473
a program that need modification are those parts that require direct knowledge of the particular
class that is added to the hierarchy. We will study two substantial class hierarchies
and will show how objects throughout those hierarchies are manipulated polymorphically.
9.11 Type Fields and switch Statements
One means of dealing with objects of many different types is to use a switch statement
to take an appropriate action on each object, based on that object’s type. For example, in a
hierarchy of shapes in which each shape has a shapeType instance variable, a switch
structure could determine which print method to call based on the object’s shapeType.
There are many problems with using switch logic. The programmer might forget to
make such a type test when one is warranted. The programmer might forget to test all possible
cases in a switch. If a switch-based system is modified by adding new types, the
programmer might forget to insert the new cases in existing switch statements. Every
addition or deletion of a class demands that every switch statement in the system be modified;
tracking these down can be time consuming and error prone.
As we will see, polymorphic programming can eliminate the need for switch logic.
The programmer can use Java’s polymorphism mechanism to perform the equivalent logic
automatically, thus avoiding the kinds of errors typically associated with switch logic.
Testing and Debugging Tip 9.2
An interesting consequence of using polymorphism is that programs take on a simplified appearance.
They contain less branching logic in favor of simpler sequential code. This simplification
facilitates testing, debugging, and program maintenance. 9.2
9.12 Dynamic Method Binding
Suppose a set of shape classes such as Circle, Triangle, Rectangle, Square, are
all derived from superclass Shape. In object-oriented programming, each of these classes
might be endowed with the ability to draw itself. Each class has its own draw method, and
the draw method implementation for each shape is quite different. When drawing a shape,
whatever that shape may be, it would be nice to be able to treat all these shapes generically
as objects of the superclass Shape. Then, to draw any shape, we could simply call method
draw of superclass Shape and let the program determine dynamically (i.e., at execution
time) which subclass draw method to use from the actual object’s type.
To enable this kind of behavior, we declare draw in the superclass, and then we override
draw in each of the subclasses to draw the appropriate shape.
Software Engineering Observation 9.16
When a subclass chooses not to redefine a method, the subclass simply inherits its immediate
superclass’s method definition. 9.16
If we use a superclass reference to refer to a subclass object and invoke the draw
method, the program will choose the correct subclass’s draw method dynamically (i.e., at
execution time). This is called dynamic method binding. Dynamic method binding is an
important mechanism for implementing polymorphic processing of objects and will be
illustrated in the case studies later in this chapter
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 7/7/01