Visual Basic.NET How to Program (PDF)

396 Object-Oriented Programming: Polymorphism Chapter 10
3. Referring to a derived-class object with a base-class reference is safe, because the
derived-class object is an object of its base class. However, this reference can refer
only to base-class members. If this code refers to derived-class-only members
through the base-class reference, the compiler reports an error.
4. Referring to a base-class object with a derived-class reference generates a compiler
error (when Option Strict is On). To avoid this error, the derived-class reference
first must be cast to a base-class reference. In this cast, the derived-class
reference must reference a derived-class object, or Visual Basic generates an InvalidCastException.
Common Programming Error 10.4
After assigning a derived-class object to a base-class reference, attempting to reference derived-class-only
members with the base-class reference is a syntax error. 10.4
Common Programming Error 10.5
Treating a base-class object as a derived-class object can cause errors. 10.5
Though it is convenient to treat derived-class objects as base-class objects by manipulating
derived-class objects with base-class references, doing so can cause significant problems.
For example, in a payroll system we need to be able to walk through an array of
employees and calculate the weekly pay for each person. Intuition suggests that using baseclass
references would enable the program to call only the base-class payroll calculation
routine (if there is such a routine in the base class). We need a way to invoke the proper
payroll calculation routine for each object, whether it is a base-class object or a derivedclass
object, and to do this simply by using the base-class reference. We learn how to create
classes that include this behavior as we introduce polymorphism throughout this chapter.
10.3 Type Fields and Select Case Statements
One way to determine the type of an object that is incorporated in a larger program is to use
a Select Case statement. This allows us to distinguish among object types, then invoke
an appropriate action for a particular object. For example, in a hierarchy of shapes in which
each shape object has an mShapeType instance variable, a Select Case structure could
employ the object’s mShapeType to determine which Print method to call.
However, using Select-Case logic exposes programs to a variety of potential problems.
For example, the programmer might forget to include a type test when one is warranted
or the programmer might forget to test all possible cases in a Select Case. When
modifying a Select-Case-based system by adding new types, the programmer might
forget to insert the new cases in all relevant Select-Case statements. Every addition or
deletion of a class requires the modification of every Select-Case statement in the
system; tracking these statements down can be time-consuming and error-prone.
Software Engineering Observation 10.2
Polymorphic programming can eliminate the need for unnecessary Select-Case logic. By
using Visual Basic’s polymorphism mechanism to perform the equivalent logic, programmers
can avoid the kinds of errors typically associated with Select-Case logic. 10.0