Let's consider a VB7 version of Person that has public, protected, and private variables and methods, and an Employee class derived from it. We will also make the getJob method abstract in the base Person class, which means we indicate it with the MustOverride keyword.

Public MustInherit Class Person
    'Class Person
    Private age As Short
    Protected personName As String
    '-----
    Public Sub init(ByRef nm As String)
        personName = nm
    End Sub
    '-----
    Public Function makeJob() As String
        makeJob = "hired"
    End Function
    '-----
    Private Sub splitNames()

    End Sub
    '-----
    Public Function getAge() As Short
        getAge = age
    End Function
    '-----
    Public MustOverride Function getJob() As String
End Class

We now derive the Employee class from it, and fill in some code for the getJob method.

Public Class Employee
    Inherits Person
    Public Overrides Function getJob() As System.String
        Return "Worker"
    End Function
End Class

You represent inheritance using a solid line and a hollow triangular arrow. For the simple Employee class that is a subclass of Person, we represent this in UML, as shown in Figure 2-3.

Figure 2-3. The UML diagram showing Employee derived from Person

Note that the name of the Employee class is not in italics because it is now a concrete class and because it includes a concrete method for the formerly abstract getJob method. While it has been conventional to show the inheritance with the arrow pointing up to the superclass, UML does not require this, and sometimes a different layout is clearer or uses space more efficiently.

An interface looks much like inheritance, except that the arrow has a dotted line tail, as shown in Figure 2-4. The name <<interface>> may also be shown, enclosed in double angle brackets, or guillamets.

Figure 2-4. ExitCommand implements the Command interface.

Much of the time, a useful representation of a class hierarchy must include how objects are contained in other objects. For example, a small company might include one Employee and one Person (perhaps a contractor).

Public Class Company
  Private emp as Employee
  Private pers as Person
End Class

We represent this in UML, as shown in Figure 2-5.

Figure 2-5. Company contains instances of Person and Employee.

The lines between classes show that there can be 0 to 1 instances of Person in Company and 0 to 1 instances of Employee in Company. The diamonds indicate the aggregation of classes within Company.

If there can be many instances of a class inside another, such as the array of Employees shown here

Public Class Company
  Private emp() as Employee
  Private pers
End Class

we represent that object composition as a single line with either a “*” on it or “0, *” on it, as shown in Figure 2-6.

Figure 2-6. Company contains any number of instances of Employee.

Some writers have used hollow and solid diamond arrowheads to indicate containment of aggregates and circle arrowheads for single object composition, but this is not required.

You will also find it convenient to annotate your UML or insert comments to explain which class calls a method in which other class. You can place a comment anywhere you want in a UML diagram. Comments may be enclosed in a box with a turned corner or just entered as text. Text comments are usually shown along an arrow line, indicating the nature of the method that is called, as shown in Figure 2-7.

Figure 2-7. A comment is often shown in a box with a turned-down corner.

UML is quite a powerful way of representing object relationships in programs, and there are more diagram features in the full specification. However, the preceding brief discussion covers the markup methods we use in this text.

All of the UML programs in this book were drawn using the WithClass program from MicroGold. This program reads in the actual compiled classes and generates the UML class diagrams we show here. We have edited many of these class diagrams to show only the most important methods and relationships. However, the complete WithClass diagram files for each design pattern are stored in that pattern's directory. Thus, you can run your demo copy of WithClass on the enclosed CD and read it and investigate the detailed UML diagram starting with the same drawings you see here in the book.

All of the programs in this book were written using Visual Basic 6.0 and VB.NET, using the project file feature. Each subdirectory of the CD-ROM contains the project file for that project so you can load the project and compile it as we did.