Inheritance and VB.NET
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
This article assumes some programming knowledge, the ability to work within an Integrated Development Environment and some familiarity with object-oriented technologies. This material is based on Beta 2 release version of Microsoft's .NET technology.
To some people, Inheritance is one of the most exciting features of Visual Basic.NET - a feature that is considered fundamental to the creation of object-based systems and that has been missing from VB until this version. I am not going to argue with this opinion, but somehow I managed to build systems for many years before .NET arrived, without inheritance. Regardless, the addition of inheritance to the Visual Basic language is an important feature and worth a little discussion.
Objects are a way to represent concepts or entities in code, and each of the object features of Visual Basic is designed to help you make the most useful representation possible. In many situations, one entity or concept is really what we would call a subobject of a more basic entity or concept. Many examples of this are used in programming books, and sadly I am not going to come up with anything too revolutionary. Consider our class of objects designed to represent cars, such as a Ford Mustang, Toyota Celica, or Chevy Cavalier. The class would have various properties such as Doors (number of doors the car has), MaxSpeed, Color, and others.
This general Car class really contains several subclasses of objects, such as Hatchbacks and Convertibles. Those classes would, of course, have all the properties of their parent class, Car, such as Doors, MaxSpeed, and Color, but they could also have unique properties of their own. A hatchback could have properties that described the size and behavior of its rear door. This relationship, between Car and its subclasses of Hatchback and Convertible, would be considered to be a parent-child relationship, and the method for representing this relationship in our systems is called inheritance. The class Hatchback is said to inherit from its base class Car. This relationship means that, in addition to any properties and methods created in the child class, the child will also possess all the properties and methods of the parent.
The previous example started with our Car class and headed downwards. Let's take the same starting point of Car and head upwards for a more detailed example of inheritance. To start, we could have a base class of Vehicle, which could represent any type of vehicle (boat, car, truck, plane) and has the properties of MaxSpeed, NumberOfPassengers, Color, and Description. We could easily represent this class in Visual Basic code, as shown in Listing 7.1.
Listing 7.1 Our Vehicle Class
Public Class Vehicle
Public Property MaxSpeed() As Long
Get
End Get
Set
End Set
End Property
Public Property NumberOfPassengers() As Long
Get
End Get
Set
End Set
End Property
Public Property Color() As String
Get
End Get
Set
End Set
End Property
Public Function Description() As String
End Function
End Class
The code that goes within the various procedures in that class is not really relevant to our example, so we will just leave it blank for now. If we were to jump to some code to try using our object (for instance, in the Sub Main() section), we would see that we can create objects of type Vehicle and work with their properties, as in Listing 7.2.
Listing 7.2 Working with Our Vehicle Class
Module Main
Sub Main()
Dim objVehicle As Vehicle
objVehicle = New Vehicle
objVehicle.Color = "Red"
objVehicle.MaxSpeed = 100
End Sub
End Module
Now, by adding an additional class to our project, we can create a class, Car, that inherits from Vehicle, just like the real class of object Car is a subclass or child of the Vehicle class of objects. Because we are creating a class designed to deal with just cars, we can add a couple of properties (NumberOfDoors and NumberOfTires) specific to this subclass of Vehicle as shown in Listing 7.3.
Listing 7.3 Working with Our Vehicle Class
Public Class Car
Inherits Vehicle
Public Property NumberOfTires() As Long
Get
End Get
Set
End Set
End Property
Public Property NumberOfDoors() As Long
Get
End Get
Set
End Set
End Property
End Class
The key to this code is the line Inherits Vehicle, which tells Visual Basic that this class is a child of the Vehicle class and therefore should inherit of all that class's properties and methods. Once again, no code is actually placed into any of these property definitions because they are not really relevant at this time. After that code is in place, without having to do anything else, we can see the effect of the Inherits statement.
Returning to our Main() procedure, we can create an object of type Car, and we'll quickly see that it exposes both its own properties and those of the parent class.
When an inherited class adds new methods or properties, it is said to be extending the base class. In addition to extending, it is also possible for a child class to override some or all of the functionality of the base class. This is done when the child implements a method or property that is also defined in the parent or base class. In such a case, the code in the child will be executed instead of the code in the parent, allowing you to create specialized versions of the base method or property.
For a child class to override some part of the base class, that portion must be marked Overridable in the base class definition. For instance, in the version of Vehicle listed earlier, none of its properties had the keyword Overridable and therefore child classes would be unable to provide their own implementations. As an example of how overriding is set up in the base and child classes, the code in Listing 7.4 marks the Description() function as being overridable and then overrides it in the Car child class. Note that non-relevant portions of the two classes have been removed for clarity.
Listing 7.4 Using the Overridable and Overrides Keywords
Public Class Vehicle
'Code removed for simplicity....
Overridable Public Function Description() As String
Return "This is my generic vehicle description!"
End Function
End Class
Public Class Car
Inherits Vehicle
'Code removed for simplicity....
Overrides Public Function Description() As String
Return "This is my Car Description"
End Function
End Class
When overriding a method or property, as we did in Listing 7.4, you can refer back to the original member of the base class by using the built-in object MyBase. For example, to refer to the existing Description() method of the Vehicle class, we could call MyBase.Description() from within the Description method of Car. This functionality allows you to provide additional functionality through overriding without having to redo all the original code as well.
In addition to marking code as Overridable, it is also possible to mark a method or property as MustOverride and a class as MustInherit. The MustOverride keyword indicates that any child of this class must provide its own version of this property or method, and the MustInherit keyword means that this class cannot be used on its own (you must base other classes off of it). It is important to note that if a class contains a method marked MustOverride, then the class itself must be marked as MustInherit.
Inheritance is a big topic, and we haven't covered it all; but with the information provided in here, you are ready to start designing some applications that take advantage of this object-oriented feature.