View Single Post
 
Old 03-26-2004, 05:43 PM
excaliber's Avatar
excaliber excaliber is offline
Senior Contributor

* Expert *
 
Join Date: Nov 2002
Location: Ohio, USA
Posts: 1,828
Default

Introduction
Inheritance is a big part of Object Oriented Programming (OOP). It allows classes to specify a 'super-class', allowing property and method reuse in an intelligent manner. Inheritance can usually be described using a good analogy.

A Scenario
Lets assume you are building some software for a warehouse. The warehouse sells all kinds of musical products, such as a guitars and drums. We see three objects here. There are products, drums and guitars. We can also see that both drums and guitars are both products, so by default probably share some similarities.

For instance, both a guitar and a drum would have a CheckInventory() method, to see if it's in stock. They would also both probably have a brand name property, and a serial number. The drum would have a special method for shipping (as it requires special preparation to ship), and the guitar would have a special property for what type of guitar it was (acoustic or electric).

Non-Inheritance Method
If you were to forego inheritance, you would need to create two classes, a drum class and a guitar class. Each class would have to include code for CheckInventory, name property, serial property, and any special methods/properties. Assume you have hundreds of products, each with special requirements that make them unique. Thats alot of code to bang out, and alot of redundancy.

Inheritance Method
Inheritance solves this. There are two types of inheritance: interface and implementation. We are going to look at implementation today. Lets look at the above scenario, and see how inheritance makes life alot easier.

Base Class
To start, we need to define a base class (also sometimes referred to as a super-class). The base class contains all code that is common to all 'derived' classes (classes that use the base class). In this case, the drum and guitar are both products. So we will create a product base class. The product class will contain the CheckInventory method, the name property, and the serial number property. It will hold these as all products share these features, and thus the same code.

Fairly simple code. We've got a class that contains a method, and two properties that expose two datastructures.

Code:
Public Class Product Private strName as string Private strSerial as string Public Function CheckInventory() as Boolean 'Code for checking inventory status here End Function Public Property Name() as String Get Name() = strName End Get Set(ByVal Value as String) strName = Value End Set End Property Public Property Serial() as String Get Serial() = strSerial End Get Set(ByVal Value as String) strSerial = Value End Set End Property

Guitar Class (Derived Class)
Now for the inheritance portion. The drum has a special method for packaging, while the guitar has a special property for the type. Heres the code for the Guitar class:

Code:
Public Class Guitar 'Inherit the methods/properties of the Product class Inherits Product Private strType as String 'Additional property to add to the existing properties/methods of Product Public Property Type() as String Get Type() = strType End Get Set(ByVal Value as String) strType = Value End Set End Property End Class

Notice the "Inherits Product" line. This forces the class to inherit the properties and methods of Product, as well as exposing the methods and properties of the Guitar class. Here is some sample code for the Drum class:

Drum Class (Derived Class)

Code:
Public Class Drum Inherits Product Public Function Ship() 'Shipping code here End Function End Class

Just as simple, eh? Here is some code to utilize the three above classes:

Using the Guitar Class
Code:
Dim name As String Dim serial As String Dim type As String 'Notice how Order() is declared as a product, and 'not as a Guitar or Drum class. Dim Order() As Product 'We redimension and set the new member to a Guitar class redim Order(0) Order(0) = new Guitar 'Utilizes the properties of the base Product class name = Order(0).Name serial = Order(0).Serial 'Utilizes the property from the derived class, Guitar 'The type conversion is needed to tell the compiler he 'shouldn't worry: the Product object does indeed have 'the Type property, because it's a Guitar type = CType(Order(0), Guitar).Type If Order(0).CheckInventory = True Then MsgBox("In Stock") End if 'Now lets do the same for the Drum class redim Preserve Order(UBound(Order)+1) 'cache the UBound for convience Dim upperB as integer UpperB = UBound(Order) 'We redimension and set the new member to a Drum class Order(UpperB) = new Drum 'Utilizes the properties of the base Product class name = Order(UpperB).Name serial = Order(UpperB).Serial If Order(UpperB).CheckInventory = True Then MsgBox("In Stock") End if CType(Order(upperB), Drum).Ship()

Lets look at a couple of things. First, notice how the original Order() variable was declared as a Product class? Because it was declared as a Product, it can be set to any class that Inherits the product class. A parent class can always handle any child class. If we would have declared Order() as a Guitar, it could only handle Guitar classes. By declaring as Product, this gives us better flexibility. This enables us to declare the object, then set it later to what we want. Lets also look at all the methods and properties that each class Inherits from Product.

Code:
 Guitar
 Name (Property from Product)
 Serial (Property from Product)
 InventoryCheck (Method from Product)
 -Type (Property from the Guitar class)
 
 Drum
 Name (Property from Product)
 Serial (Property from Product)
 InventoryCheck (Method from Product)
 -Ship (Method from the Drum Class)
Overriding Methods and Properties
The next small section will talk about Overriding. Overriding allows you to use a new method/property in place of an old one. Using our analogy, lets say the Drum class needs a different InventoryCheck method. The manufacturer wants to keep track of the number of times the method has been called (to see how often people check on it). This means that it will have to use a different method in place of the old CheckInventory method inherited from Product. We could create an entirely new method with a new name, but thats wasteful and confusing. Instead, we need to go back and edit the CheckInventory method in Product to add one keyword:

Code:
Public Overridable Function CheckInventory() as Boolean 'Code for checking inventory status here End Function

Notice the keyword "Overridable"? By placing that in the Product's version of the method, it allows us to "Override", or use our own, method in other classes. Here is how to override it in the Drum Class:

Code:
Public Overrides Function CheckInventory() as Boolean 'old code to check inventory '- 'New code to 'track' the number of times called End Function

This time we use a new keyword, "Overrides". This means that this function takes the place of the function named the same in the parent class. When CheckInventory is called, this function will be used instead of the one from Product. These two keywords can be used on anything, from functions to subs to properties. But if you look at it, its still wasteful. We are repeating the original code in the new function. Theres a way around this. Since ultimately Product is a subclass of the System.Object class, it can use MyBase to interact with its base class and use its methods. Heres how it can help:

Code:
Public Overrides Function CheckInventory() As Boolean Dim result As Boolean 'Call our base's version of CheckInventory result = MyBase.CheckInventory 'New code to 'track' the number of times called End Function

In that example, we call Product's original CheckInventory method, then proceed to add to it using new code. This is efficient and allows us to utilize old code while customizing it for the Drum class. Note that his may only be helpful in certain situations. There may (and will) be times when you need a completely different version of the method. This is just a little trick to help if it fits your situation.

Conclusion
This tutorial demonstrated how a Product class could contain methods that are shared for all products. A Drum and Guitar class were made that used the methods in Product, but also added their own, without waste. We also modified overrode the default CheckInventory method with one of our own in the Drum class, and used MyBase to keep waste to a minimum. Pretty cool, eh?
__________________
RandomIRC - Your neighborhood's friendly IRC channel (irc.randomirc.com - #code)

"Perl - The only language that looks the same before and after RSA encryption."

Last edited by reboot; 09-13-2004 at 08:00 AM. Reason: De-greened the text.
Reply With Quote