This article will explain what polymorphism is and how it can help you design and reuse code in Object-Oriented Programming.  You’ll learn what polymorphism is and how to use it.  In the following examples, I’ll be using Visual Basic .NET, but any language that supports Object-Oriented Programming should be able to use these same techniques.

If you have not already read the articles on Understanding Objects and Understanding Inheritance, please check them out as some of the terms and other information explained there will be used in this article.

What is Polymorphism?

According to dictionary.com, the definition of Polymorphism is as follows:

3. Biology The occurrence of different forms, stages, or types in individual organisms or in organisms of the same species, independent of sexual variations.

So, how does this relate to programming?  We’ll develop Objects that have different forms of the same “species”.  The great thing about Polymorphism is that when you are building your program, you assume you are working with the “species” Object, but you actually use an individual “organism” Object.  This allows the “organism” Objects to be exchanged in the code for one another.

In other words, say we have a Parent Class called Animal and two Child Classes that Inherit from Animal called Cat and Dog.  The Cat and Dog are both Animals, so they will inherit all the properties and methods that an Animal has.  If we wanted to store an array of Cats or Dogs, we could just declare the array to be of type Animal and then we’d be able to store either Cats or Dogs within the array.  That is Polymorphism.

Parent Classes and Interfaces

Both Parent Classes and Interfaces can be used to setup an Object as the “species” level.  Parent Classes have been explained in Understanding Inheritance.

What is an Interface?

An Object’s Interface is how you communicate or interact with that Object.  Interfaces in programming terms are similar to a Class Object, but an Interface does not implement the properties or methods it declares, it simply declares them.

Why is this useful?  Interfaces force the Class Objects that implement the Interface to have all of the properties and methods of the Interface.  So, the following IAnimal Interface could be implemented by Cat and Dog to force them to implement the properties, Height and Weight, along with the methods, Eat and Drink.

Public Interface IAnimal

    Property Height() As Integer
    Property Weight() As Integer

    Function Eat(footType As String) As Boolean
    Function Drink(drinkType As String) As Boolean

End Interface

Interfaces can be used with Parent or Child classes and multiple Interfaces can be used by one Class.  Also, in some cases, you may want to use an Interface in place of a Parent Class, forcing all properties and methods to be fully implemented in each class.  Another thing to keep in mind is that a Parent Class that implements the IAnimal Interface does not have to fully implement all properties and methods.  Instead, the Parent Class could implement those common properties or methods that will not change no matter the Child Class, and leave the others to be implemented by the Child Class.  In VB.NET, you can use the MustOverride keyword on the function declaration.  This will make the Parent Class an Abstract class.

Public MustInherit Class Animal Implements IAnimal

    'Data Members.
    Private _height As Integer
    Private _weight As Integer

    Public Property Height() As Integer Implements IAnimal.Height
        Get
            return _height
        End Get
        Set(ByVal Value As Integer)
            _height = value
        End Set
    End Property

    Public Property Weight() As Integer Implements IAnimal.Weight
        Get
            Return _weight
        End Get
        Set(ByVal Value As Integer)
            _weight = Value
        End Set
    End Property

    'Abstract Functions.
    Public MustOverride Function Eat(foodType As String) As Boolean Implements IAnimal.Eat
    Public MustOverride Function Drink(drinkType As String) As Boolean Implements IAnimal.Drink

End Class

 Now, things are looking pretty good.  We can force are Classes to implement certain properties and methods, but there is still one downside.  Our methods are passing in a String value for foodType and drinkType.  What if we wanted to use a different data type, such as our own Object that holds other properties for foodType?  We don’t want to have to modify the Interface or Parent Class each time this may change.  What we want to do is make the Class or Interface Generic.

How do I make my Interface or Class Generic?

Making a Class or Interface Generic will make your code more reusable.  When you make a Class or Interface Generic, you don’t have to know what type of data you will be using with the Object until you declare or create an instance of the Object.  So, various programs could use the same Class Object, but passing in different data types to work with when instantiating the Object. 

Public Interface IAnimal(Of T)

    Property Height() As Integer
    Property Weight() As Integer

    Function Eat(foodType As T) As Boolean
    Function Drink(drinkType As T) As Boolean

End Interface

T is a place holder for the type of data we will declare later on.  Notice in the declaration of the Interface and both methods, Eat and Drink, T is used.  Now, when we create a Cat or Dog using the IAnimal Interface, we can determine what type of data will be used for foodType and drinkType.

Public Class Cat Implements IAnimal(Of String)

This would declare a Cat to use a String data type to store the foodType and drinkType.

Public Class Dog Implements IAnimal(Of Integer)

And this one would declare a Dog to use an Integer data type to store the foodType and drinkType.

We could also define our own complex Class Object as the data type.

Advantages of using Polymorphism, Interfaces, and Generic Objects

• Polymorphism allows you to use similar types of data together.  It also can be used to improve system maintenance, reuse code, and easily setup testing Objects that mimic communications with databases and other resources.
• Interfaces force the implementation of properties and methods on Objects that implement the Interface.
• Generic Objects allow more reusable code when building Class Objects and Interfaces.