This print for content only-size & color not accurate 7" X 9-1/4" / casebound / malloy

// Car 'has-a' Radio

private Radio myRadio = new Radio();

public void TurnOnRadio(bool onOff)

{

// Delegate call to inner object.

myRadio.Power(onOff);

}

}

Notice that the object user has no clue that the Car class is making use of an inner Radio object.

static void Main(string[] args)

{

// Call is forwarded to Radio internally.

Car viper = new Car();

viper.TurnOnRadio(false);

}

C H A P T E R   5  

■

D E F I N I N G   E N C A P S U L AT E D   C L A S S  T Y P E S

161

8849CH05.qxd  10/22/07  1:34 PM  Page 161

---

The Role of Polymorphism

The final pillar of OOP is polymorphism. This trait captures a language’s ability to treat related

objects in a similar manner. Specifically, this tenant of an object-oriented language allows a base

class to define a set of members (formally termed the 

polymorphic interface) that are available to all

descendents. A class’s polymorphic interface is constructed using any number of 

virtual or abstract

members (see Chapter 6 for full details).

In a nutshell, a 

virtual member is a member in a base class that defines a default implementa-

tion that may be changed (or more formally speaking, 

overridden) by a derived class. In contrast, an

abstract method is a member in a base class that does not provide a default implementation, but

does provide a signature. When a class derives from a base class defining an abstract method, it

must be overridden by a derived type. In either case, when derived types override the members

defined by a base class, they are essentially redefining how they respond to the same request.

To preview polymorphism, let’s provide some details behind the shapes hierarchy shown in

Figure 5-8. Assume that the Shape class has defined a virtual method named Draw() that takes no

parameters. Given the fact that every shape needs to render itself in a unique manner, subclasses

(such as Hexagon and Circle) are free to override this method to their own liking (see Figure 5-9).

Figure 5-9.

Classical polymorphism

Once a polymorphic interface has been designed, you can begin to make various assumptions

in your code. For example, given that Hexagon and Circle derive from a common parent (Shape), an

array of Shape types could contain anything deriving from this base class. Furthermore, given that

Shape defines a polymorphic interface to all derived types (the Draw() method in this example), we

can assume each member in the array has this functionality.

Consider the following Main() method, which instructs an array of Shape-derived types to ren-

der themselves using the Draw() method:

class Program

{

static void Main(string[] args)

{

Shape[] myShapes = new Shape[3];

myShapes[0] = new Hexagon();

myShapes[1] = new Circle();

myShapes[2] = new Hexagon();

foreach (Shape s in myShapes)

{

s.Draw();

}

C H A P T E R   5