1

Chapter 10 – Object-Oriented
Programming: Polymorphism
Outline
10.1 Introduction
10.2 Derived-Class-Object to Base-Class-Object Conversion
10.3 Type Fields and switch Statements
10.4 Polymorphism Examples
10.5 Abstract Classes and Methods
10.6 Case Study: Inheriting Interface and Implementation
10.7 sealed Classes and Methods
10.8 Case Study: Payroll System Using Polymorphism
10.9 Case Study: Creating and Using Interfaces
10.10 Delegates
10.11 Operator Overloading
 2

10.1 Introduction

• Polymorphism allows programmers to write:

– Programs that handle a wide variety of related classes in a
generic manner
– Systems that are easily extensible
 3
10.2 Derived-Class-Object to Base-Class-Object
Conversion
• Class hierarchies
– Can assign derived-class objects to base-class references
– Can explicitly cast between types in a class hierarchy
• An object of a derived-class can be treated as an
object of its base-class
– Array of base-class references that refer to objects of many
derived-class types
– Base-class object is NOT an object of any of its derived
classes
 4
1 // Fig. 10.1: Point.cs
2 // Point class represents an x-y coordinate Definition
pair. of class Point
3
4 using System;
5 Point.cs
6 // Point class definition implicitly inherits from Object
7 public class Point
8 {
9 // point coordinate
10 private int x, y;
11
12 // default constructor
13 public Point()
14 {
15 // implicit call to Object constructor occurs here
16 }
17
18 // constructor
19 public Point( int xValue, int yValue )
20 {
21 // implicit call to Object constructor occurs here
22 X = xValue;
23 Y = yValue;
24 }
25
26 // property X
27 public int X
28 {
29 get
30 {
31 return x;
32 }
33
 5
34 set
35 {
36 x = value; // no need for validation
37 }
38 Point.cs
39 } // end property X
40
41 // property Y
42 public int Y
43 {
44 get
45 {
46 return y;
47 }
48
49 set
50 {
51 y = value; // no need for validation
52 }
53
54 } // end property Y
55
56 // return string representation of Point
57 public override string ToString()
58 {
59 return "[" + X + ", " + Y + "]";
60 }
61
62 } // end class Point
 6
1 // Fig. 10.2: Circle.cs
2 Definition
// Circle class that inherits from of class
class Point. Circle which
3
4 using System;
inherits from class Point
5 Circle.cs
6 // Circle class definition inherits from Point
7 public class Circle : Point
8 {
9 private double radius; // circle's radius
10
11 // default constructor
12 public Circle()
13 {
14 // implicit call to Point constructor occurs here
15 }
16
17 // constructor
18 public Circle( int xValue, int yValue, double radiusValue )
19 : base( xValue, yValue )
20 {
21 Radius = radiusValue;
22 }
23
24 // property Radius
25 public double Radius
26 {
27 get
28 {
29 return radius;
30 }
31
 7
32 set
33 {
34 if ( value >= 0 ) // validate radius
35 radius = value;
36 } Circle.cs
37
38 } // end property Radius
39
40 // calculate Circle diameter
41 public double Diameter()
42 {
43 return Radius * 2;
44 }
45
46 // calculate Circle circumference
47 public double Circumference()
48 {
49 return Math.PI * Diameter();
50 }
51
52 // calculate Circle area
53 public virtual double Area()
54 {
55 return Math.PI * Math.Pow( Radius, 2 );
56 }
57
58 // return string representation of Circle
59 public override string ToString()
60 {
61 return "Center = " + base.ToString() +
62 "; Radius = " + Radius;
63 }
64
65 } // end class Circle
 8
1 // Fig. 10.3: PointCircleTest.cs
2 // Demonstrating inheritance and polymorphism.
3
4 using System; Create a Point object
5 using System.Windows.Forms; PointCircleTest.
Assign a Point reference to cs
6 Createreference
a Circle aobject
Circle object
7 // PointCircleTest class definition
8 class PointCircleTest
9 { Use base-class reference to
10 // main entry point for application. Assign a Circle referenceaccess a derived-class object
11 static void Main( string[] args ) to reference a Point object
12 { (downcast)
13 Point point1 = new Point( 30, 50 );
14 Circle circle1 = new Circle( 120, 89, 2.7 );
15
16 string output = "Point point1: " + point1.ToString() +
Use derived-class
17 "\nCircle circle1: " + circle1.ToString(); reference to access a
18 base-class object
19 // use 'is a' relationship to assign
20 // Circle circle1 to Point reference
21 Point point2 = circle1;
22
23 output += "\n\nCCircle circle1 (via point2): " +
24 point2.ToString();
25
26 // downcast (cast base-class reference to derived-class
27 // data type) point2 to Circle circle2
28 Circle circle2 = ( Circle ) point2;
29
30 output += "\n\nCircle circle1 (via circle2): " +
31 circle2.ToString();
32
33 output += "\nArea of circle1 (via circle2): " +
34 circle2.Area().ToString( "F" );
35
 9
36 // attempt to assign point1 object to Circle reference
37 if ( point1 is Circle )
38 {
39 circle2 = ( Circle ) point1;
40 output += "\n\ncast successful"; PointCircleTest.
41 } cs
42 else
43 {
44 output += "\n\npoint1 does not refer to a Circle";
45 }
46
47 MessageBox.Show( output,
48 "Demonstrating the 'is a' relationship" );
49
50 } // end method Main Test if point1 references a Circle
51 object – it cannot, because of the
52 } // end class PointCircleTest
downcasting on line 28

Program Output
 10

10.4 Polymorphism Examples

• Quadrilateral base-class
– Rectangle derived-class
– Square derived-class
– Parallelogram derived-class
– Trapezoid derived-class
– Method perimeter might need to be invoked on all classes
– With a Quadrilateral reference, C# polymorphically
chooses the correct overriding method in the derived-class
from which the object is instantiated
 11

10.4 Polymorphism Examples

• SpaceObject base-class – contains method DrawYourself

– Martian derived-class (implements DrawYourself)
– Venutian derived-class (implements DrawYourself)
– Plutonian derived-class (implements DrawYourself)
– SpaceShip derived-class (implements DrawYourself)
• A screen-manager program may contain a SpaceObject
array of references to objects of various classes that derive
from SpaceObject
• To refresh the screen, the screen-manager calls
DrawYourself on each object in the array
• The program polymorphically calls the appropriate version
of DrawYourself on each object, based on the type of that
object
 12

10.5 Abstract Classes and Methods

• Abstract classes
– Cannot be instantiated
– Used as base classes
– Class definitions are not complete – derived classes must
define the missing pieces
– Can contain abstract methods and/or abstract properties
• Have no implementation
• Derived classes must override inherited abstract methods and
properties to enable instantiation
 13

10.5 Abstract Classes and Methods

• Abstract classes are used to provide appropriate

base classes from which other classes may inherit
(concrete classes)
• Abstract base classes are too generic to define real
objects
• To define an abstract class, use keyword abstract
in the declaration
• To declare a method or property abstract, use
keyword abstract in the declaration; abstract
methods and properties have no implementation
 14

10.5 Abstract Classes and Methods

• Concrete classes use the keyword override to

provide implementations for all the abstract
methods and properties of the base-class
• Any class with an abstract method or property
must be declared abstract
• Even though abstract classes cannot be
instantiated, we can use abstract class references
to refer to instances of any concrete class derived
from the abstract class
 15
10.6 Case Study: Inheriting Interface and
Implementation
• Abstract base class Shape
– Concrete virtual method Area (default return value is 0)
– Concrete virtual method Volume (default return value is 0)
– Abstract read-only property Name
• Class Point2 inherits from Shape
– Overrides property Name (required)
– Does NOT override methods Area and Volume
• Class Circle2 inherits from Point2
– Overrides property Name
– Overrides method Area, but not Volume
• Class Cylinder2 inherits from Circle2
– Overrides property Name
– Overrides methods Area and Volume
 16
1 // Fig. 10.4: Shape.cs
2 // Demonstrate a shape hierarchy using an abstract base class.
3 using System;
4 Declaration of virtual methods Shape.cs
5 public abstract class Shape
6 {
Area and Volume with default
7 // return Shape's area implementations
8 public virtual double Area()
9 {
10 return 0; Declaration of read-only abstract property
11 } Name; implementing classes will have to
12
13 // return Shape's volume provide an implementation for this property
14 public virtual double Volume()
15 { Declaration of abstract class Shape
16 return 0;
17 }
18
19 // return Shape's name
20 public abstract string Name
21 {
22 get;
23 }
24 }
 17
1 // Fig. 10.5: Point2.cs
2 // Point2 inherits from abstract class Shape and represents
3 // an x-y coordinate pair.
4 using System;
5 Point2.cs
6 // Point2 inherits from abstract class Shape
7 public class Point2 : Shape
8 {
9 private int x, y; // Point2 coordinates
10
11 // default constructor
12 public Point2()
13 {
14 // implicit call to Object constructor occurs here
15 }
16
17 // constructor
18 public Point2( int xValue, int yValue )
19 {
20 X = xValue;
21 Y = yValue;
22 } Class Point2 inherits from class Shape
23
24 // property X
25 public int X
26 {
27 get
28 {
29 return x;
30 }
31
32 set
33 {
34 x = value; // no validation needed
35 }
 18
36 }
37
38 // property Y
39 public int Y
40 { Point2’s implementation of the Point2.cs
41 get read-only Name property
42 {
43 return y;
44 }
45
46 set
47 {
48 y = value; // no validation needed
49 }
50 }
51
52 // return string representation of Point2 object
53 public override string ToString()
54 {
55 return "[" + X + ", " + Y + "]";
56 }
57
58 // implement abstract property Name of class Shape
59 public override string Name
60 {
61 get
62 {
63 return "Point2";
64 }
65 }
66
67 } // end class Point2
 19
1 // Fig. 10.6: Circle2.cs
2 // Circle2 inherits from class Point2 and overrides key members.
3 using System;
4
5 // Circle2 inherits from class Point2 Circle2.cs
6 public class Circle2 : Point2
7 {
8 private double radius; // Circle2 radius
9
10 // default constructor
11 public Circle2()
12 {
13 // implicit call to Point2 constructor occurs here
14 }
15
16 // constructor
17 public Circle2( int xValue, int yValue, double radiusValue )
18 : base( xValue, yValue )
19 {
20 Radius = radiusValue;
21 } Definition of class Circle2 which
22 inherits from class Point2
23 // property Radius
24 public double Radius
25 {
26 get
27 {
28 return radius;
29 }
30
 20
31 set
32 {
33 // ensure non-negative radius value
34 if ( value >= 0 )
35 radius = value; Circle2.cs
36 } Override the Area method
37 }
38 (defined in class Shape)
39 // calculate Circle2 diameter
40 public double Diameter()
41 {
42 return Radius * 2;
43 }
44
45 // calculate Circle2 circumference
46 public double Circumference()
47 {
48 return Math.PI * Diameter();
49 }
50
51 // calculate Circle2 area
52 public override double Area()
53 {
54 return Math.PI * Math.Pow( Radius, 2 );
55 }
56
57 // return string representation of Circle2 object
58 public override string ToString()
59 {
60 return "Center = " + base.ToString() +
61 "; Radius = " + Radius;
62 }
 21
63
64 // override property Name from class Point2
65 public override string Name
66 {
67 get Circle2.cs
68 {
69 return "Circle2";
70 }
71 }
72
73 } // end class Circle2
Override the read-only Name property
 22
1 // Fig. 10.7: Cylinder2.cs
2 // Cylinder2 inherits from class Circle2 and overrides key members.
3 using System;
4
5 // Cylinder2 inherits from class Circle2 Cylinder2.cs
6 public class Cylinder2 : Circle2
7 {
8 private double height; // Cylinder2 height
9
10 // default constructor
11 public Cylinder2()
12 {
13 // implicit call to Circle2 constructor occurs here
14 }
15
16 // constructor
17 public Cylinder2( int xValue, int yValue, double radiusValue,
18 double heightValue ) : base( xValue, yValue, radiusValue )
19 {
20 Height = heightValue;
21 }
22
23 // property Height
24 public double Height
25 { Class Cylinder2
26 get derives from Circle2
27 {
28 return height;
29 }
30
31 set
32 {
33 // ensure non-negative height value
34 if ( value >= 0 )
35 height = value;
 23
36 }
37 }
38 Override read-only property Name
39 // calculate Cylinder2 area
40 public override double Area() Cylinder2.cs
41 {
42 return 2 * base.Area() + base.Circumference() * Height;
43 }
44
45 // calculate Cylinder2 volume
46 public override double Volume()
47 {
48 return base.Area() * Height;
49 }
50
51 // return string representation of Circle2 object
52 public override string ToString()
53 {
54 return base.ToString() + "; Height = " + Height;
55 }
56
57 // override property Name from class Circle2
58 public override string Name
59 {
60 get Override Area implementation of class Circle2
61 {
62 return "Cylinder2";
63 }
64 } Override Volume implementation of class Shape
65
66 } // end class Cylinder2
 24
1 // Fig. 10.8: AbstractShapesTest.cs
2 // Demonstrates polymorphism in Point-Circle-Cylinder hierarchy.
3 using System;
4 using System.Windows.Forms; Assign a Shape reference AbstractShapesTe
5
6 public class AbstractShapesTest
to Create an
reference array
a of
Point2 Shape
object objects st.cs
7 { Assign a Shape reference to
8 public static void Main( string[] args ) Assign a aShape reference to
9 {
reference Cylinder2 object
10 reference
// instantiate Point2, Circle2 and Cylinder2 a Circle2 object
objects
11 Point2 point = new Point2( 7, 11 );
12 Circle2 circle = new Circle2( 22, 8, 3.5 );
13 Cylinder2 cylinder = new Cylinder2( 10, 10, 3.3, 10 );
14
15 // create empty array of Shape base-class references
16 Shape[] arrayOfShapes = new Shape[ 3 ];
17
18 // arrayOfShapes[ 0 ] refers to Point2 object
19 arrayOfShapes[ 0 ] = point;
20
21 // arrayOfShapes[ 1 ] refers to Circle2 object
22 arrayOfShapes[ 1 ] = circle;
23
24 // arrayOfShapes[ 1 ] refers to Cylinder2 object
25 arrayOfShapes[ 2 ] = cylinder;
26
27 string output = point.Name + ": " + point + "\n" +
28 circle.Name + ": " + circle + "\n" +
29 cylinder.Name + ": " + cylinder;
30
 25
31 // display Name, Area and Volume for each object
32// in arrayOfShapes polymorphically

AbstractShapesTe
st.cs
33 foreach( Shape shape in arrayOfShapes )
34 {
35 output += "\n\n" + shape.Name + ": " + shape +
36 "\nArea = " + shape.Area().ToString( "F" ) +
37 "\nVolume = " + shape.Volume().ToString( "F" );
38 }
39
Use a foreach loop to access Rely on polymorphism to call
40 every element
MessageBox.Show( output,of "Demonstrating
the array Polymorphism" );
appropriate version of methods
41 }
42 }
Program Output
 26
1. namespace P1
2. {
3. public abstract class A
4. {
5. public abstract void print();
6. }

7. public class B:A {

8. string str;

9. public B()
10. {
11. str = "Hello";
12. }
13. public override void print()
14. {
15. Console.WriteLine(str);
16. }

17. }
27
28
29
 30

10.7 sealed Classes and Methods

• sealed is a keyword in C#
• sealed methods cannot be overridden in a derived
class
– Methods that are declared static and private, are implicitly
sealed
• sealed classes cannot have any derived-classes
• Creating sealed classes can allow some runtime
optimizations
31
32
33
 34
10.8 Case Study: Payroll System Using
Polymorphism
• Base-class Employee
– abstract
– abstract method Earnings
• Classes that derive from Employee
– Boss
– CommissionWorker
– PieceWorker
– HourlyWorker
• All derived-classes implement method Earnings
• Driver program uses Employee references to refer to
instances of derived-classes
• Polymorphism calls the correct version of Earnings
 35
1 // Fig. 10.9: Employee.cs
2 // Abstract base class for company employees.
3 using System;
4
5 public abstract class Employee Employee.cs
6 {
7 private string firstName;
8 private string lastName;
9
10 // constructor
11 public Employee( string firstNameValue,
12 string lastNameValue )
13 {
14 FirstName = firstNameValue;
15 LastName = lastNameValue;
16 }
17 Definition of abstract class Employee
18 // property FirstName
19 public string FirstName
20 {
21 get
22 {
23 return firstName;
24 }
25
26 set
27 {
28 firstName = value;
29 }
30 }
31
 36
32 // property LastName
33 public string LastName
34 {
35 get
36 { Declaration of abstract class Employee.cs
37 return lastName; Earnings – implementation must
38 } be provided by all derived classes
39
40 set
41 {
42 lastName = value;
43 }
44 }
45
46 // return string representation of Employee
47 public override string ToString()
48 {
49 return FirstName + " " + LastName;
50 }
51
52 // abstract method that must be implemented for each derived
53 // class of Employee to calculate specific earnings
54 public abstract decimal Earnings();
55
56 } // end class Employee
 37
1 // Fig. 10.10: Boss.cs
2 // Boss class derived from Employee.
3 using System;
4
5 public class Boss : Employee Boss.cs
6 {
7 private decimal salary; // Boss's salary
8
9 // constructor
10 public Boss( string firstNameValue, string lastNameValue,
11 decimal salaryValue)
12 : base( firstNameValue, lastNameValue )
13 {
14 WeeklySalary = salaryValue;
15 }
16
17 // property WeeklySalary
18 public decimal WeeklySalary
19 { Definition of class Boss –
20 get
21 {
derives from Employee
22 return salary;
23 }
24
25 set
26 {
27 // ensure positive salary value
28 if ( value > 0 )
29 salary = value;
30 }
31 }
32
 38
33 // override base-class method to calculate Boss's earnings
34 public override decimal Earnings()
35 {
36 return WeeklySalary;
37 } Boss.cs
38
39 // return string representation of Boss
40 public override string ToString()
41 {
42 return "Boss: " + base.ToString();
43 }
44 }
Implementation of method Earnings (required
by classes deriving from Employee)
 39
1 // Fig. 10.11: CommisionWorker.cs
2 // CommissionWorker class derived from Employee
3 using System;
4
5 public class CommissionWorker : Employee CommisionWorker.
6 { cs
7 private decimal salary; // base weekly salary
8 private decimal commission; // amount paid per item sold
9 private int quantity; // total items sold
10
11 // constructor
12 public CommissionWorker( string firstNameValue,
13 string lastNameValue, decimal salaryValue,
14 decimal commissionValue, int quantityValue )
15 : base( firstNameValue, lastNameValue )
16 {
17 WeeklySalary = salaryValue;
18 Commission = commissionValue;
19 Quantity = quantityValue;
20 }
21 Definition of class CommissionWorker
22 // property WeeklySalary
23 public decimal WeeklySalary – derives from Employee
24 {
25 get
26 {
27 return salary;
28 }
29
 40
30 set
31 {
32 // ensure non-negative salary value
33 if ( value > 0 )
34 salary = value; CommisionWorker.
35 } cs
36 }
37
38 // property Commission
39 public decimal Commission
40 {
41 get
42 {
43 return commission;
44 }
45
46 set
47 {
48 // ensure non-negative commission value
49 if ( value > 0 )
50 commission = value;
51 }
52 }
53
54 // property Quantity
55 public int Quantity
56 {
57 get
58 {
59 return quantity;
60 }
61
 41
62 set
63 {
64 // ensure non-negative quantity value
65 if ( value > 0 )
66 quantity = value; CommisionWorker.
67 } cs
68 }
69
70 // override base-class method to calculate
71 // CommissionWorker's earnings
72 public override decimal Earnings()
73 {
74 return WeeklySalary + Commission * Quantity;
75 }
76
77 // return string representation of CommissionWorker
78 public override string ToString()
79 {
80 return "CommissionWorker: " + base.ToString();
81 }
82 Implementation of method Earnings (required
83 } // end class CommissionWorker
by classes deriving from Employee)
 42
1 // Fig. 10.12: PieceWorker.cs
2 // PieceWorker class derived from Employee.
3 using System;
4
5 public class PieceWorker : Employee PieceWorker.cs
6 {
7 private decimal wagePerPiece; // wage per piece produced
8 private int quantity; // quantity of pieces produced
9
10 // constructor
11 public PieceWorker( string firstNameValue,
12 string lastNameValue, decimal wagePerPieceValue,
13 int quantityValue )
14 : base( firstNameValue, lastNameValue )
15 {
16 WagePerPiece = wagePerPieceValue;
17 Quantity = quantityValue;
18 } Definition of class PieceWorker
19
20 // property WagePerPiece – derives from Employee
21 public decimal WagePerPiece
22 {
23 get
24 {
25 return wagePerPiece;
26 }
27
28 set
29 {
30 if ( value > 0 )
31 wagePerPiece = value;
32 }
33 }
34
 43
35 // property Quantity
36 public int Quantity
37 {
38 get
39 { PieceWorker.cs
40 return quantity;
41 }
42
43 set
44 {
45 if ( value > 0 )
46 quantity = value;
47 }
48 }
49
50 // override base-class method to calculate
51 // PieceWorker's earnings
52 public override decimal Earnings()
53 {
54 return Quantity * WagePerPiece;
55 }
56
57 // return string representation of PieceWorker
58 public override string ToString()
59 {
60 return "PieceWorker: " + base.ToString();
61 }
62 }
Implementation of method Earnings (required
by classes deriving from Employee)
 44
1 // Fig. 10.13: HourlyWorker.cs
2 // HourlyWorker class derived from Employee.
3 using System;
4
5 public class HourlyWorker : Employee HourlyWorker.cs
6 {
7 private decimal wage; // wage per hour of work
8 private double hoursWorked; // hours worked during week
9
10 // constructor
11 public HourlyWorker( string firstNameValue, string LastNameValue,
12 decimal wageValue, double hoursWorkedValue )
13 : base( firstNameValue, LastNameValue )
14 {
15 Wage = wageValue;
16 HoursWorked = hoursWorkedValue;
17 }
18 Definition of class HourlyWorker –
19 // property Wage
20 public decimal Wage derives from Employee
21 {
22 get
23 {
24 return wage;
25 }
26
27 set
28 {
29 // ensure non-negative wage value
30 if ( value > 0 )
31 wage = value;
32 }
33 }
34
 45
35 // property HoursWorked
36 public double HoursWorked
37 {
38 get
39 { HourlyWorker.cs
40 return hoursWorked;
41 }
42
43 set
44 {
45 // ensure non-negative hoursWorked value
46 if ( value > 0 )
47 hoursWorked = value;
48 }
49 }
50
51 // override base-class method to calculate
52 // HourlyWorker earnings
53 public override decimal Earnings()
54 {
55 // compensate for overtime (paid "time-and-a-half")
56 if ( HoursWorked <= 40 )
57 {
58 return Wage * Convert.ToDecimal( HoursWorked );
59 }
60 Implementation of method Earnings (required
61 else by classes deriving from Employee)
62 {
63 // calculate base and overtime pay
64 decimal basePay = Wage * Convert.ToDecimal( 40 );
65 decimal overtimePay = Wage * 1.5M *
66 Convert.ToDecimal( HoursWorked - 40 );
67
 46
68 return basePay + overtimePay;
69 }
70 }
71
72 // return string representation of HourlyWorker HourlyWorker.cs
73 public override string ToString()
74 {
75 return "HourlyWorker: " + base.ToString();
76 }
77 }
 47
1 // Fig. 10.14: EmployeesTest.cs
2 // Demonstrates polymorphism by displaying earnings
3 // for various Employee types.
4 using System;
5 using System.Windows.Forms; EmployeesTest.cs
6
Assign Employee reference to
7 public class EmployeesTest reference a Boss object
8 {
9 public static void Main( string[] args ) Use method GetString to polymorphically
10 {
11
obtain salary information. Then use the original
Boss boss = new Boss( "John", "Smith", 800 );
12 Boss reference to obtain the information
13 CommissionWorker commissionWorker =
14 new CommissionWorker( "Sue", "Jones", 400, 3, 150 );
15
16 PieceWorker pieceWorker = new PieceWorker( "Bob", "Lewis",
17 Convert.ToDecimal( 2.5 ), 200 );
18
19 HourlyWorker hourlyWorker = new HourlyWorker( "Karen",
20 "Price", Convert.ToDecimal( 13.75 ), 50 );
21
22 Employee employee = boss;
23
24 string output = GetString( employee ) + boss + " earned " +
25 boss.Earnings().ToString( "C" ) + "\n\n";
26
27 employee = commissionWorker;
28
29 output += GetString( employee ) + commissionWorker +
30 " earned " +
31 commissionWorker.Earnings().ToString( "C" ) + "\n\n";
32
33 employee = pieceWorker;
34
 48
35 output += GetString( employee ) + pieceWorker +
36 " earned " + pieceWorker.Earnings().ToString( "C" ) +
37 "\n\n"; Definition of method GetString,
38
39 employee = hourlyWorker; which takes as an argument an EmployeesTest.cs
40 Employee object.
41 output += GetString( employee ) + hourlyWorker +
42 " earned " + hourlyWorker.Earnings().ToString( "C" ) +
43 "\n\n";
44 Polymorphically call the method of
45 MessageBox.Show( output, "Demonstrating Polymorphism",
the appropriate derived class
46 MessageBoxButtons.OK, MessageBoxIcon.Information );
47
48 } // end method Main
49
50 // return string that contains Employee information
51 public static string GetString( Employee worker )
52 {
53 return worker.ToString() + " earned " +
54 worker.Earnings().ToString( "C" ) + "\n";
55 }
56 }

Program Output