A Tightly Coupled Relationship
Below is an example of two classes that are tightly coupled, meaning that if we want to replace object B with another class, we must change the code of object A. Object A is dependent on object B to execute.

Public Class ObjectA

  Private _obj As ObjectB

  Public Sub New(ByVal obj As ObjectB)

    _obj = obj

  End Sub

  Public Sub RunB()

    _obj.Run()

  End Sub

End Class

Public Class ObjectB

  Public Sub Run()

    Console.WriteLine("Run from objectB")

  End Sub

End Class

A Loosely Coupled Relationship
Now, let’s look at a better approach that will allow us to replace ObjectB with another class using the same interface or replace it with a child class of ObjectB.

Below, the ObjectB class now implements the IObjectB interface and the references to ObjectB in ObjectA have been replaced with a reference to the interface IObjectB instead.

Public Interface IObjectB

  Sub Run()

End Interface

Public Class ObjectA

  Private _obj As IObjectB

  Public Sub New(ByVal obj As IObjectB)

    _obj = obj

  End Sub

  Public Sub RunB()

    _obj.Run()

  End Sub

End Class

Public Class ObjectB
  Implements IObjectB

  Public Sub Run() Implements IObjectB.Run

    Console.WriteLine("Run from objectB")

  End Sub

End Class

Now, ObjectA can execute no matter if we pass into it a copy of ObjectB or another class that implements the IObjectB interface. The Interface ensures that all objects that implement it will have a subroutine called Run. That is all that ObjectA needs to know. This breaks ObjectA’s dependency on ObjectB.

S

 Single Responsiblity Principle – A class should do one thing and do it well. If you can think of more than one reason to change a class, then it has more than one responsibility.

O

Open / Closed Principle – A class should be open for extension but closed for modification. Classes should be designed so they can be inherited from without having to modify them.

L

Liskov Substitution Principle – Derived classes must be substitutable for their base class. When a class method accepts an object, the method should be able to accept children of that object without knowing anything about the children.

I

Interface Segregation Principle – Interfaces should be fine grained and only provide for your needs. When building your interfaces, you should not add more functionality than what you need at the time.

D

Dependency Inversion Principle – High level modules should not depend on low level modules, but instead both should depend on abstractions. Interfaces should be used as placeholders and factory classes should be used to instantiate objects. This causes loose coupling between classes.

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.

According to dictionary.com, one definition of inheritance is:

2. the genetic characters transmitted from parent to offspring, taken collectively.

This definition also fits with Object Oriented Programming.  Remember, that our Objects mimic those found in real-life and just like in real-life, Objects can have Parent Objects or Children Objects.  Inheritance is the process of obtaining the properties and methods from another Object.  The Child Object inherits these properties and methods from the Parent Object.

Using Inheritance, we can extend the functionality of a Class Object without having to modify that Object.  This helps you make your own code more reusable as well as gives you the ability to improve other people’s Class Objects.

Access Modifiers

I had talked breifly about Access Modifiers in Understanding Objects.  When building Parent and Child Class Objects, you will most likely be using all three: Private, Public and Protected.

A Child Class that inherits from a Parent does not gain access to all of the Parent’s properties and methods.  The Parent uses Encapsulation and Data Hiding to protect it’s Private properties and methods.  The Child Class can only access those properties and methods that are Protected or make up the Public Interface for the Parent Class.

The Protected access modifier acts similar to Private, keeping the properties and methods hidden from outside use, but it will allow Child Class Objects access to them.

Below is an example of a Parent Class:

Public Class MyParent

    Private _hiddenVariable As String
    Private _errors As String

    Public Sub New()

        _hiddenVariable = “”
        _errors = “”

    End Sub

    Protected Sub AddError(error As String)

        _errors += error + VbCrLf

    End Sub

    Public Function GetErrors()

        Return _errors

    End Function

End Class

Below is an example of a Child Class:

Public Class MyChild
    Inherits MyParent

    Public Sub New()

        MyBase.New()

    End Sub

    Public Function MyNewFunction()

        Return "It Worked!"

    End Function

End Class

In the above examples, the Parent Class has a couple Private string variables.  The subroutine, AddError, would normally be a Private function, but since we want the Child Class to have access to this function, we must change it to Protected.

There are two methods on MyParent’s Public Interface: New() and GetErrors().

The MyChild Class uses Inheritance to extend MyParent’s functionality.  In VB, the Inherits keyword is used to tell which class is the Parent.  Within MyChild, all of the functions on the Public Interface for MyParent as well as the Protected function, AddError, can be accessed.

There are three methods on MyChild’s Public Interface: New(), GetErrors(), and MyNewFunction().

Overriding Methods

When developing a Child Class, you may find that you need to change the way that one of the Parent Class’ methods work.  To do this, you must override the method in the Child Class.  When an instance of the Child Class is used, the overridden function would be used within the Child Class instead of the Parent Class.

Some languages allow you to override the function by simply declaring the same function in the Child as in the Parent.  In VB, you would use the Overrides keyword to declare you are overriding a function.

Protected Overrides Sub AddError(error As String)

    _errors += "MyChild:" + error + VbCrLf

End Sub

This subroutine would be placed in the MyChild Class and would override the AddError subroutine found in the MyParent Class.  Errors that occur in the Child Class would show “MyChild:” in front of them.

Also, the Child method that overrides the Parent, can also call the Parent’s method.  This allows you the power of performing some small change without having to re-implement the entire method in the Child Class.  In VB, you would use the MyBase keyword to signal you are looking for the Parent Class version of the method.

MyBase.AddError("my error")

Abstraction

Abstraction is the process of declaring a Class, property or method without giving the details on the implementation of that element.  A Parent Class can use Abstraction to declare that a function must be present in any Child Class of that Parent.  The Child Class can then either define what the method does or declare the method as Abstract also.

If a Class is Abstract, then an instance of that Class can not be created.  You must instead, access the Class through one of it’s children. 

In VB, you can force a Class to be Abstract by using the MustInherit keyword.

Public MustInherit Class MyParent

Below is an example of the MyParent Class if we wanted to make the AddError function Abstract. 

Public Class MyParent

    Private _hiddenVariable As String
    Private _errors As String

    Public Sub New()

        _hiddenVariable = “”
        _errors = “”

    End Sub

    Protected MustOverride Sub AddError(error As String)

    Public Function GetErrors()

        Return _errors

    End Function

End Class

Advantages of Inheritance, Abstraction, and Overriding Methods

• Inheritance helps you extend the functionality of your own classes or other people’s classes.
• Abstraction can be useful if you need multiple Classes that have similar properties and methods.  You can create an Abstract Parent Class with the common properties and methods and have the Children Classes hold the unique properties and methods.
• Overriding Methods allows you to change the functionality of a Parent Class without modifying the Parent’s code.

Programming Objects store the state of an Object in internal variables and has methods that are used to access that information.

Access Modifiers

Access modifiers let you set the access level of class properties or functions.

• Private – Only this class’ functions can use the item.
• Public – This class’ functions and any outside source can use the item.
• Protected – This class or any Child Class can use the item.

Encapsulation

In Object-Oriented Programming, your Class files have internal data members, or variables.  These variables hold properties of the Object.  By setting your Class variables to Private or Protected, you ensure that anyone using your Class cannot access the data directly.  If the variable needs to be accessed outside the Class, then Get or Set functions can be setup to allow access.  This ensures that your Class’ data cannot be changed without your knowledge.  This is called Encapsulation and allows for Data Hiding.

Imagine a radio Object in the example on the right-side where the two Class variables (in green) are Encapsulated in the object and surrounded by the Public Interface (in blue) to those variables.

One of the benefits of using Get and Set functions to access your Class variables is that you can do some validation to make sure the data is valid before storing it.

Public Interface

Each object, or Class file, you create will have a Public Interface that allows your program, or other classes, to communicate with it.  By using the Public access modifier, you allow anyone who creates an instance of your Class to access that Class variable or function.

Advantages of Object Oriented Programming

• OOP creates a natural structure to your code mimicking real-world examples we can see.
• Code that deals with an Object is grouped together making it easier to reuse and maintain.
• Encapsulation allows for greater control over what variables can store.