Lecture 11 - Polymorphism (vb 2008)

Lecture 11: Polymorphism

Outline 

In the last lecture, we continued our discussion of Objects… 

Creating and Using Constructors:  



Used to create object instances with differing characteristics. Example: JTrain (cont.)

Inheritance 

Which we used to create ‘Derived Classes’... 







Which inherit the characteristics of a Base Class

Example: The JFreightTrain Class

Overriding Base Class Constructors

This lecture, we continue our discussion of Overriding… 

With Polymorphism, a simple but powerful concept  



This will be illustrated with a generalized Multiple-JTrain Example… 



Form 1 : Overriding Base Class Methods and Properties. Form 2 : The Ability of Methods to Accept ‘Related’ Classes. That uses both ‘forms’ of Polymorphism (this and next lecture).

We will also learn the basics of creating our own custom Collections: 

Similar to Collections.ArrayList, but defined by us… 

By inheriting from the .NET System Class, CollectionBase.

Polymorphism 

It is often useful to re-define base-class Methods or Properties… 

So that many forms exist for the same basic behavior. 



For instance, consider the Base Class, ‘Animal’. 



And 2 Derived Classes: Cat and Wolf.

All Animals sleep, but the derived classes may sleep for different times. 



This is called polymorphism = Multiple (poly-) + Form (-morph) + ism

Defining different ‘Sleep’ methods for each provides ‘polymorphism’.

Here, we discuss two types of Inheritance-based Polymorphism: 

Overriding Base Class Methods 



We saw this already, with Constructors…

Polymorphism at Method Interfaces 

The ability of Methods to deal with ‘Related’ Objects ‘at the Interface’: 

Parameters and Return Value Types

Polymorphism and Overriding 

Basic Inheritance-based Polymorphism is provided by Overriding: 

First, a Method is defined in a Base Class. 

That Method is then re-defined (overridden) in a Derived Class… 



A client of the Method (and Object) does not have to realize this. 

The Method may the be called more-or-less freely…  





Without knowing which Class (Base or Derived) an instance belongs to. Or even that several different behaviors have been defined.

The behavior defined for each specific type will simply occur, automatically.

This is important for encapsulation : 



So that the Base and Derived methods exhibit different behaviors.

‘Unnecessary’ object details can be hidden from object clients, for simplicity !

We already considered an example of overriding last lecture… 

A special-case example involves Constructors:  

We defined Class-specific Constructors for our derived class: JFreightTrain. No additional keywords were required.

Overriding (cont.) 

We may also override Base Class Methods other than New()… 

Example: The JTrain’s GetStatus() Method: 

Currently reports only Passenger Car Number. 





But: users might want information about Wagon Number, as well.

So, let’s override the method for JFreightTrain!

This more general type of overriding requires several steps: 1. You must declare that the Base Class Method is Overridable. 

Of course, the Method must be implemented by the Base Class.

2. The ‘Overrides’ keyword must then be used in the new Method’s definition. 



i.e., in the Derived Class.

Example: Let’s change the GetStatus() Method of JFreightTrain…  

So that it also reports the number of Wagons (not only Cars). But first, let’s talk about Visibility.

The Issue of Accessibility 

In VB .NET, each element is defined to have a set ‘Visibility’: 

In other words, limits are defined on the accessibility:  





Of a Variable, Member, or Property for reading, or being written to; Of Procedures (Methods) for use.

Again, this is important for compartmentalization and data hiding.

Visibility levels available in VB.NET include: 

Public (*): 



Friend (*): 





May be accessed within the same Class, or Derived Classes. Usable only within Classes (in fact, it will be useful to us, here).

Private (*):  



Accessible from within the Current Project, but not from outside projects.

Protected: 



Accessible within the Current Project, or in Other Projects that reference it.

May only be accessed within the same Module, Class, or Structure. Private is the default visibility.

* Useable within Modules, Structures, or Classes, but not Procedures.

Example:

Polymorphism and Procedures 

Polymorphism also applies to behavior at Procedure ‘Interfaces’: 

If a Method accepts/passes an instance of a Base Class as a Parameter…  



Ex: A Method defined to accept a JTrain can also accept a JFreightTrain. 



It can also accept/pass an Instance of any Derived Class Instance, instead. This is a simple example of polymorphism at an ‘Interface’. Since everything a JTrain can do, a JFreightTrain can also do.

There are a couple of limitations on this: 

This doesn’t work backwards…  



A Method defined to accept a Derived Class can’t accept the Base Class. Ex: A Method in Module1 which accepts a JFreightTrain can’t accept a JTrain.

Common-sense must also prevail. 

If you try to call a behavior specific to a Derived Class inside the Method…  



You will get an error, even though the parameter pass would be successful. Why? The behavior may not be defined for the Base Class.

One work-around: Provide a consistent interface at the Base Class. 

Make sure it provides minimal implementations of all ‘derived’ Methods:  

At least an ‘Empty’ Method for each Method implemented by a derived Class. Ex: Define an empty ‘AddWagon()’ for JTrain, that does nothing.

Collections.CollectionBase 

Back in Course 1, we learned about creating two types of lists: 1. Array : A basic, indexed list of elements.  

All elements must be the same primitive type… Supported Methods provide very basic list functionality.

2. ArrayList : An Object-based indexed list.  

With elements that could be quite general (not all the same type). Provided Methods: Add(), Remove(), and Find() 





These did a lot of ‘housekeeping’ for us, along the way ( resizing, etc. )

ArrayList is actually: System.Collection.ArrayList

When working with a list, it is best to define your own Collection… 

This is a Special purpose ‘list’ (kind of like ArrayList)… 



that Inherits from System.Collections.CollectionBase

Creating your new Collection is very simple: 

First, define the new Collection as a Class inheriting from CollectionBase 



This Collection contains an inherited List that can be manipulated…

To act on the List, you must define the following 3 resources:   

Add( x ) – This method appends item x to the Collection’s List Remove( i ) – This Method deletes the item at index i from the List Find( i ) – This Property gets the item at index i in the List

Example: The trains Collection 

Our Goal will be to Generalize our JTrain Project: 

We will define and use our own Collection called trains: 

Which can contain either JTrain or JFreightTrain Elements… 

So that we can add, remove, and command many trains at once.

1. We will need to add several new Procedures to Module1: 

AddTrain() 



FindTrain (String name) 



Which finds a train called name in trains

CommandTrain (String name)  



Which Adds a new Train to trains

Which allows the user to command a train in trains called ‘name’. For this, we will use the Select Case command structure we already have…

All should work with either JTrain or JFreightTrain (polymorphism!) 

For this, we must add 2 empty Wagon Methods to JTrain.

2. We will also need to update the Main() method of Module1… 

To allow us to use all of these Procedures with trains. 



For this, we will define some new Commands.

Finally, we will test functionality!

Trains Example: Some Preliminaries

The JTrainCollection Class

The CommandTrain() Method

The AddTrain() Method

Overview / Forward 

In this lecture, we have continued our discussion of Objects… 

With Polymorphism, a simple but powerful concept  



Form 1 : Overriding Base Class Methods and Properties. Form 2 : The Ability of Methods to Accept ‘Related’ Classes.

We also started to create our own custom Collection: 

Similar to Collections.ArrayList, but defined by us… 



By inheriting from the .NET System Class, CollectionBase.

Next Lecture: 

We will finish our ArrayList… 



And illustrate, with a generalized Multiple-JTrain Example.

And combine our JTrain Classes 

into a new Class Library called ‘TrainsLib’.