Object Oriented Programming Language Features

Inheritance comes in two forms. Interface and Implementation inheritance. Interface inheritance is available in Visual Basic since VB6's introduction of the Implements keyword. Implementation inheritance is available as of VB.NET with the Inherits keyword.

The main difference between the two inheritances is that interface inheritance should specify only a contract of desired behavior. It should not allow any corresponding implementation code. It is up to other classes, which realize that interface, to provide the implementation.

Implementation inheritance lets subclasses share common code and attributes (properties). Also, implementation inheritance's ability to declare an operation abstract enables it to act similar to interface inheritance and force subclasses to implement the operation instead.

A VB.NET class can only enter into an implementation inheritance relationship with one superclass (also called base or ancestor class). However, VB.NET, like VB6, lets that same class enter into as many interface inheritance relationships as it chooses.

An example may help. Say you are developing an app in which the Store object wants to ask an instance of the Stereo class to calculate availability inventory. However, the Stereo class wants to borrow the functionality already provided by its superclass, Product. The Store object might implement such functionality like this:

   Private myStereo as Stereo
   Private Function getInventory() As Integer
      getInventory = myStereo.calcInventory()
   End Function

The real implementation of this behavior is in Product's calcInventory() method. Because VB6 doesn't support implementation inheritance you need to put some code in the Stereo class:

   Implements Product

   Private myProductObject as New Product
   Private Function Product_calcInventory() As Integer
      Product_calcInventory = myProductObject.calcInventory()
   End Function

VB6 allows the interface, the Product class, to implement the actual behavior. Stereo keeps an instance of Product (containment) then asks that reference to do some work for it (delegation). This type of interface inheritance is not a true interface because it allows you to add code to Stereo to provide the actual behavior.

With VB.NET you can remove the containment and delegation code by using implementation inheritance. For example, in the Stereo class:

   Inherits Product
   '
   ' any unique Stereo code
   '

The Store class makes a calculation request similar to the way the Stereo class makes this request, but Stereo carries out the work much differently in VB.NET. The Stereo instance, myStereo, doesn't contain a calcInventory() method so VB looks up its superclass, Product, and executes its calcInventory() procedure.

Implementation inheritance also allows you to override superclass operations. An Items class might use this to provide its own implementation of calcInventory() which would cancel out the behavior provided by its Product superclass. For instance:

   Overrides Function calcInventory() As Integer
   '
   ' any unique Items code
   '
   End Function

All of the above may sound a bit confusing if you have not used inheritance in the past. Take a second to reread the above and you will see that it is really not that difficult. Interface inheritance tends to be a little harder to grasp for some but, again, it is not that though of a concept.

When to Use Inheritance

Implementation inheritance allows you to reduce your code base drastically since subclasses gain the methods of their superclass. This is a mixed blessing. If you start with a poor design you will end up with code that is more difficult than ever to debug and maintain.

Code and attributes once common in the superclass may not remain common as the app's business needs evolve over time. Eventually many subclasses may end up overriding the behavior of the superclass. Worse, the subclass may override the superclass, do its own work, then call the same operation again on the superclass. Believe me, I've seen it happen in other languages.

VB.NET requires you explicitly use the Overrides and Inherits keywords. Most languages do not mandate this and are smart enough to know on their own. I believe this is a good thing. It provides self documentation and instant visual clue as to whether a method is overridden or not simplifying maintenance and debugging.

Use Interface Inheritance When:

• The base or superclass represents a generic facility such as a table lookup, unique algorithm,...
  
• The number of common operations is small.
  
• The base class has few, if any, attributes.
  
• Classes realizing the interface are diverse, with little or no common code.

Use Implementation Inheritance When:

• The base class is an entity class (business or domain class) of primary interest to the application (not a utility or control class).
  
• The implementations are complex with a large number of operations.
  
• Many operations and attributes are common across the subclasses.

Polymorphism

Polymorphism means many forms. It gives classes the ability to define the same operation but provide unique implementations of that operation. In other words, each of the class' methods is different. You can use polymorphism with either interface or implementation inheritance.

Polymorphism is more than overriding a superclass's operations which is a small part of polymorphism's power. For an operation to be polymorphic it must implement an operation defined in an interface it implements or it must implement an operation defined in a superclass. The superclass' operation is typically abstract, which means it has no implementation code.

For example, you might encounter the getInformation() operation defined in Product as abstract. If another object refers to either a Stereo or Items object and wants to send it a message, it is best not to hard code that class name:

   Public Function getProductInfo(myProduct as Product) As Boolean
      myProduct.getInformation()
   End Function

The input parameter's data type is Product. VB is smart enough to know whether the function is asking Stereo or Items to get its information.

Encapsulation

Encapsulation is also called information hiding and ensures that no other class has knowledge about attributes and/or behavior unless the class publishes them expressly.

VB lets you declare attributes and behaviors with the Private keyword inside a class module. This hides them from the world outside of the class. Conversly, if declared with the Public keyword other objects can access those properties and methods yet know nothing of their actual implementation.

Overloading

Overloading lets a function vary its behavior based on its input parameters. VB.NET lets you have multiple functions with the same name but with different input parameters. The language knows which version to execute based on what is pased in. An example:

   Overloads Function calcInventory() As Integer
   '
   ' any code unique to this no parameter version.
   '
   End Function

   Overloads Function calcInventory(dteDate as Date) As Integer
   '
   ' code unique to this date driven version.
   '
   End Function

   Overloads Function calcInventory(StartDate as Date, EndDate as Date) As Integer
   '
   ' code unique to the date range version.
   '
   End Function

Shared Members

Sometimes you need to provide behavior on behalf of all objects in a particular class and maintaining attributes that all instances of a class can have access to. VB.NET uses shared members to resolves this issue. Other languages call these feature static or instance operations.

If the Product class needs to maintain an attribute and operation that are available to all of its instances, you might implement the Product class like this:

   Shared TotalProductCount As Integer
   Shared Function calcTotalProductCount As Integer
   '
   ' get count of all products.
   '
   End Function

These attributes do not require an object instance to use them. In VB6 you can create a variable in a .bas module that is acessible from all objects of a given class. This achieves the same function but is not very object-oriented.