The Moth

On his blog, as part of a useful OOP series, Raymond Lewallen defines polymorphism. He merges 3 concepts in one post. We've had the discussion on the topic previously, but I don't think we reached total agreement. In my opinion, to say that there is such a thing as "true" polymorphism and to claim that it applies only when inheritance is involved, is plain wrong.

If you are reading that blog entry to understand polymorphism, please read my (complementary) take on the topic below.

First I would ignore overloading. This has nothing to do with polymorphism and I would not bring it up in any discussions on the topic. Just for info, overloading is the ability to define two or more methods on the same class with the same name but different argument lists. Nothing more, nothing less.

Second, do not directly associate polymorphism with inheritance (as you can probably tell this is my pet peeve :-). Polymorphism directly depends on subtyping. Unfortunately, many people confuse subtyping with implementation inheritance. Inheritance is *a* way to achieve subtyping, but not the only one (another is interface implementation). If you ask the question in reverse: Is inheritance the same as polymorphism? The answer is no. Inheritance offers a way to achieve subtyping *and* a way to reuse code.

So if someone asks you to explain polymorphism with a VB.NET example using inheritance, you can do something simple like this:

Public Class EntryPoint
    Shared Sub Main()
        Dim m As New Mouse
        Dim s As New Shark
        DoSomethingWith(m)
        DoSomethingWith(s)
    End Sub

    ' Client code
    Public Shared Sub DoSomethingWith(ByVal a As Animal)
        a.Bite()
    End Sub
End Class

Public MustInherit Class Animal
    Public MustOverride Sub Bite()
End Class

Public Class Mouse
    Inherits Animal

    Public Overrides Sub Bite()
        MsgBox("Disease")
    End Sub
End Class

Public Class Shark
    Inherits Animal

    Public Overrides Sub Bite()
        MsgBox("ouch!")
    End Sub
End Class

The client code uses the type Animal. It does not know what objects it will be given (i.e. instances of what class) but the fact that they support the programmatic interface of the Animal type is enough for it to use them: polymorphism in action.

If someone asks you to explain polymorphism with a VB6 example, you can do something like this:
In a Standard EXE project, change the startup Object in project properties to Sub Main.

Add a module1 with this code:

Sub Main()
    Dim m As New Mouse
    Dim s As New Shark
    DoSomethingWith m
    DoSomethingWith s
End Sub

' Client code
Sub DoSomethingWith(ByVal a As Animal)
    a.Bite
End Sub

Add a Animal class module:

Public Sub Bite()
End Sub

Add a Mouse class module:

Implements Animal
Private Sub Animal_Bite()
    MsgBox "Disease"
End Sub

Add a Shark class module:

Implements Animal
Private Sub Animal_Bite()
    MsgBox "ouch!"
End Sub

That's it. Polymorphism in VB6: nothing fake or incomplete about it.

Naturally you can mix many concepts in your designs including polymorphism, inheritance and overloading etc. If you want to see a design combining these topics, then Raymond's post has a nice VB.NET example.