The following sections discuss two of the most important advantages provided by interfaces: multiple inheritance and code generalization.

Private Sub DisplayValues(ByVal items() As String)
    lstItems.Items.Clear()
    For Each item As String In items
        lstItems.Items.Add(item)
    Next item
End Sub

Private Sub DisplayValues(ByVal items As List(Of String))
    lstItems.Items.Clear()
    For Each item As String In items
        lstItems.Items.Add(item)
    Next item
End Sub

Private Sub DisplayValues(ByVal items As IList(Of String))
    lstItems.Items.Clear()
    For Each item As String In items
        lstItems.Items.Add(item)
    Next item
End Sub

To make a class that implements an interface, add an Implements statement after the Class statement and any Inherits statements. For example, the following code shows the declaration for a Manager class that inherits from Person and implements IComparable:

Public Class Manager
    Inherits Person
    Implements IComparable

    ...
End Class

The only other thing you need to do is implement the properties, methods, and events defined by the interface. The IComparable interface defines a CompareTo function that takes an object as a parameter and returns an integer that is less than, equal to, or greater than zero to indicate whether the object should be considered less than, equal to, or greater than the parameter.

For example, the following code shows a Person class that defines FirstName and LastName properties. It implements IComparable(Of Person) to order Person objects according to their last names first.

Public Class Person
    Implements IComparable(Of Person)

    Public Property FirstName As String
    Public Property LastName As String

' Compare this Person to another Person.
    Public Function CompareTo(
     ByVal other As Person) As Integer Implements System.
     IComparable(Of Person).CompareTo
        ' If our last name comes first, we come first.
        If (LastName.CompareTo(other.LastName) < 0) Then Return −1

        ' If our last name comes second, we come second.
        If (LastName.CompareTo(other.LastName) > 0) Then Return 1

        ' If our last names are the same, compare first names.
        Return FirstName.CompareTo(other.FirstName)
    End Function
End Class

If the current object's LastName alphabetically precedes the other object's LastName, the function returns −1. If the current object's LastName alphabetically follows the other object's LastName, the function returns 1.

If the two objects' LastNames are the same, the function compares their FirstNames and returns the result.

Visual Studio is very helpful in writing methods to implement interfaces. When you type the Implements statement and press [Enter], Visual Studio generates empty properties, methods, and events to implement the interface. All you need to do is fill in their code. For example, if you type Implements IComparable(Of Person) and press [Enter], Visual Studio generates the following code (I added the line break to make the code fit in the book):

Public Function CompareTo(ByVal other As Person) As Integer _
 Implements System.IComparable(Of Person).CompareTo

End Function

Now you just need to fill in the code.

There are several ways you can learn more about what an interface is for and what it does. First, you can search the online help. Second, you can right-click on the interface's name in the Code Editor and select Go To Definition to see information, as shown in Figure 29-1.

Figure 29.1. FIGURE 29-1

Finally, you can open the Object Browser (use the View menu's Object Browser command) and search for the interface's name to see a display similar to the one provided by the Go To Definition command (refer to Figure 29-1).

The examples in the preceding sections implement predefined interfaces. This section explains how you can define your own.

Defining an interface is a lot like defining a class with two main differences:

The following code shows a simple IDrawable interface:

Public Interface IDrawable
    Property X As Integer
    Property Y As Integer
    Property Background As Brush
    Property Foreground As Pen
    Sub Draw(ByVal gr As Graphics)
End Interface

A class that implements IDrawable must provide X, Y, Background, and Foreground properties, and a Draw subroutine.

The declarations for the properties look like they are providing a default implementation for them, but they actually only define the required accessors. A class that implements IDrawable must still provide its own implementations, although it can use auto-implemented properties. For example, the following code shows how the DrawableCircle class implements its X property:

Public Property X As Integer Implements IDrawable.X

In this Try It, you build the Vehicle class and the IDomicile interface described earlier in this lesson. You then make a MotorHome class that inherits from the first and implements the second. Finally, you create an instance of the derived class.