WindowsDevCenter.com
oreilly.comSafari Books Online.Conferences.

advertisement


AddThis Social Bookmark Button

Object Oriented Programming for VB.NET - Part 2
Pages: 1, 2, 3

Method Overriding

Sometimes when you extend a base class, you may want to have a method that has the same name as the one in the base class but does something different. In VB.NET you can do this by using the keyword Overridable in front of the declaration of the method in the base class. Then, in the derived class, you use the keyword Overrides in front of the method with the same name. This technique is called method overriding.



For example, Listing 16 shows a class called Employee with a method called Work. The method is declared overridable, meaning that the method can be overridden in the inheriting classes.

Listing 16: An overridable method


Imports System
Class Employee
  Overridable Public Sub Work() 
    Console.Write("I am an employee.")
  End Sub
End Class

The code in Listing 17 is a class called Manager that extends the class Employee in Listing 16. In the Manager class, we provide a different implementation for the method Work.

Listing 17: Method overriding


Class Manager: Inherits Employee
  Overrides Public Sub Work() 
    Console.Write("I am a manager.")
  End Sub
End Class

You can make a method not overridable by using the keyword NotOverridable. For example, the Work method in the Employee class in Listing 18 cannot be overridden.

Listing 18: Not overridable method


Imports System
Class Employee
  NotOverridable Public Sub Work() 
    Console.Write("I am an employee.")
  End Sub
End Class

Abstract Classes

In some cases, you don't know how to write the implementation of a method in a class at the time of writing the class. Implementation can only be provided by the inheriting class. Or, you know that the method will be overridden in the child classes, so why bother providing an implementation at all? If this is the case, your class is incomplete; this is called an abstract class. The method that you don't provide implementation for is called an abstract method. An abstract method is denoted by the MustOverride keyword. The class itself has the MustInherit modifier because it cannot be instantiated using the New keyword.

For example, the class in Listing 19 is named Shape and it is abstract because one of the methods (Draw) does not have implementation. Other than that, the class looks like a normal class.

Listing 19: An abstract class


Imports System
MustInherit Class Shape
  Public x As Integer = 9
    Public y As Integer = 0

  MustOverride Sub Draw()

  Public Function GetInfo() As String
    GetInfo = "An abstract class"
  End Function
End Class

Note that the Draw method does not have the End Sub declaration.

When you extend an abstract class, you must provide implementations for all methods that must be overridden. Otherwise, the inheriting class itself will be an abstract class and must be declared with the MustInherit keyword.

The Rectangle and Line classes in Listing 20 inherit Shape.

Listing 20: Inheriting from an abstract class


Class Rectangle: Inherits Shape

  Overrides Sub Draw()
  ' Draw a rectangle here
  End Sub

End Class


Class Line: Inherits Shape

  Overrides Sub Draw()
  ' Draw a line here
  End Sub

End Class

Interfaces

For beginners, interfaces are probably not very clear. Why would you want to use an interface at all? An interface defines a contract that classes must adhere to.

An interface is like an abstract class. An abstract class can have methods with or without implementations; however, an interface can only have methods that don't have implementation. In an OOP language that supports only single class inheritance like VB.NET, inheritance plays a very important role. Interfaces enable multiple inheritance in VB.NET because a VB.NET class can extend multiple interfaces. Extending an interface has a special term: implement. To implement an interface in VB.NET, you use the keyword Implements. As with extending an abstract class, you must provide implementations for all methods in the interface you implement. Otherwise, you must make your class abstract.

An interface is declared using the keyword Interface. Like other types in VB.NET, there is a naming convention for interfaces. The recommendation is to use the class's naming convention and prefix the interface name with an I. For example, here are some good names for interfaces: IScalable, ISerializable, I3DShape, IPolygonShape, etc.

For example, Listing 21 presents an interface called IShape.

Listing 21: An interface called IShape


Interface IShape
End Interface

For a class to implement an interface, the same syntax as class extension is used. In the code in Listing 22, the class Line implements the IShape interface.

Listing 22: Implementing an interface


Interface IShape
End Interface

Class Line: Implements IShape
End Class

An alternative syntax would be:


Interface IShape
End Interface

Class Line
  Implements IShape
End Class

An interface in VB.NET can only have methods, properties and events. An interface cannot contain a field. All interface members are implicitly public and may not specify an access modifier. In the class that implements an interface, each method implementation must specify the interface method that it implements using the keyword Implements, followed by the name of the interface and the method name. The interface name and the method name are separated using a period. For example, the code in Listing 23 shows an interface called IShape with one method called Draw. There is also a class named Line that implements IShape.

Listing 23: Implementing an interface method


Imports System
Interface IShape
  Sub Draw()
End Interface

Class Line
  Implements IShape
  Sub Draw() Implements IShape.Draw
    Console.Write("Draw a line")
  End Sub
End Class

You can then instantiate a Line object as you would a normal class. Like abstract classes, interfaces cannot be instantiated.

Pages: 1, 2, 3

Next Pagearrow