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

// Make an array of Shape-compatible objects.

Shape[] myShapes = {new Hexagon(), new Circle(), new Hexagon("Mick"),

new Circle("Beth"), new Hexagon("Linda")};

// Loop over each item and interact with the

// polymorphic interface.

foreach (Shape s in myShapes)

{

s.Draw();

}

Console.ReadLine();

}

Figure 6-11 shows the output.

C H A P T E R   6  

■

U N D E R S TA N D I N G   I N H E R I TA N C E  A N D   P O LY M O R P H I S M

207

8849CH06.qxd  10/1/07  10:35 AM  Page 207

---

Figure 6-11.

Polymorphism in action

This Main() method illustrates polymorphism at its finest. Although it is not possible to directly

create an abstract base class (the Shape), you are able to freely store references to any subclass with

an abstract base variable. Therefore, when you are creating an array of Shapes, the array can hold

any object deriving from the Shape base class (if you attempt to place Shape-incompatible objects

into the array, you receive a compiler error).

Given that all items in the myShapes array do indeed derive from Shape, we know they all sup-

port the same polymorphic interface (or said more plainly, they all have a Draw() method). As you

iterate over the array of Shape references, it is at runtime that the underlying type is determined. At

this point, the correct version of the Draw() method is invoked.

This technique also makes it very simple to safely extend the current hierarchy. For example,

assume we derived five more classes from the abstract Shape base class (Triangle, Square, etc.). Due

to the polymorphic interface, the code within our for loop would not have to change in the slightest

as the compiler enforces that only Shape-compatible types are placed within the myShapes array.