You override a base class property by redefining a property in the derived class. You override a method by redefining a sub or function in the derived class. The signature of the overriding method must be identical to that of the base class method. That is, the parameters to the method in the derived class must match exactly the parameters to the method in the class in which it was originally defined.

The following example creates two classes that are related by inheritance. The script declares a base class named Fruit, and then declares Apple and Banana to be new classes derived from the Fruit class. The Apple and Banana classes inherit all of the Fruit class’s variables (weight and color) and the Prepare sub.

The Prepare sub is intentionally left blank in the base class. It provides general access and allows itself to be overridden and extended in the derived classes so that you can access Apple or Banana functionality via a Fruit sub. Both derived classes override the base class’s Prepare sub. The Apple class substitutes a Core sub and the Banana class substitutes a Peel sub.

Class Fruit

weight As Single
color As String
 Sub New(w As Single, c As String)
   weight! = w!
   color$ = c$
 End Sub

 Sub Prepare  
   ' Assume that each derived class will override
   ' the Prepare method.
   ' Print a message...
   Print "The Fruit class's Prepare sub doesn't do anything."
 End Sub

End Class

Class Apple As Fruit ' Derive the Apple class from the 'Fruit class.
 seedCount As Integer
 variety As String
  Sub Core          ' Add a Core sub to the Apple class.
    If (weight! > 5) Then  ' You can access base class members.
    Print "This apple core method is for apples " & _
      "of 5 lbs. or less."
    Exit Sub
    End If
    '...
    Print "The ";weight!;" lb. ";color$;" "; variety$; _
       " apple is cored."
  End Sub

  Sub New(w As Single, c As String, v As String, _
     s As Integer), Fruit (w!,c$)
   Variety$ = v$   ' Initialize the variety.
   SeedCount% = s%   ' Initialize the number of seeds.
  End Sub

   Sub Prepare
     Core     ' To prepare an apple, you core it.
  End Sub
End Class

Class Banana As Fruit
' Banana class is derived from the Fruit class.
  Sub Peel  ' Add a peel method to the Banana class.
    '.
    Print "The ";weight!;" lb. ";color$; _
" Banana is now peeled."
  End Sub
 Sub New(w As Single, c As String)
   '...
 End Sub
 
 Sub Prepare
   Peel               ' To prepare a banana, you peel it.
 End Sub
End Class

Extending Sub New for derived classes

You can define Sub New for a derived class to augment the Sub New definition of its base class. Sub New for a derived class must provide the base class Sub New with its expected parameters.

The parameter list for the Sub New of the base class can be a subset of the parameter list for the Sub New of the derived class. You can pass any expression, including a constant or a variable declared at module level, as an argument to the base class’s Sub New. You can omit the arguments for the Sub New of the base class if the arguments for the derived class Sub New and the base class Sub New are the same.

The syntax is:

Sub New [ ( paramList ) ] [ , baseClass ( baseArgList ) ]

[ statements ]

Class Fruit
 Public weight As Single
 Public color As String
 Sub New(w As Single, c As String)
   weight! = w!
   color$ = c$
   Print "Fruit New() weight = ";w!, "color =";c$
 End Sub
End Class

Class Banana As Fruit
 Sub Peel  
 '...  
 End Sub

 ' Banana accepts only a weight.  The Sub New passes both
 ' weight and color to the base class (Fruit).
 Sub New(w As Single), Fruit (w, "Yellow")
   '...
   Print "Banana New() Weight = ";w!
 End Sub
End Class

Dim z As New Banana (0.45)   ' Create a .45 lb yellow banana.

Calling Sub New and Sub Delete

When LotusScript creates an object of a derived class, the call to the Sub New for the derived class generates a call of the Sub New for the base class. If that base class is itself a derived class, LotusScript calls its base class, and so on. After all the calls, the highest-level Sub New is executed followed by the Sub New of every class in the derivation chain. The Sub New of the class of the object being created is executed last.

When LotusScript deletes an object of a derived class, it calls the Sub Delete for the derived class, followed by the Sub Delete of the base class Sub Delete, and so on for every class in the derivation chain, up to the highest base class; that is, in the reverse order of the Sub New execution.

This example shows the order in which Sub New and Sub Delete are called.

Class Fruit
 Public weight As Single
 Public color As String

  Sub New(w As Single, c As String)
   weight! = w!
   color$ = c$
   Print "Fruit: New"
  End Sub

 Sub Delete
   Print "Fruit: Delete"
 End Sub
End Class

Class Apple As Fruit
 Public seedCount As Integer

 Sub Core
 ' ...
 End Sub

 Sub New(w As Single, c As String)
   Print "Apple: New"
 End Sub

 Sub Delete
   Print "Apple: Delete"
 End Sub

End Class

Dim y As New Apple(1.14, "Red")
' Executes Fruit's Sub New and then Apple's Sub New.

Delete y
' Executes Apple's Sub Delete and then Fruit's Sub Delete.

Accessing base-class properties and methods

A derived class can call a property or method in a base class, even if that method was overridden in the derived class. You use two dots (dotdot notation) to access a base class’s overridden method. Dotdot notation is valid only in class scope (within a Class statement).

The syntax is:

baseClassName..propertyName (parameters)

or

baseClassName..methodName (parameters)

For example, you can override a method just to add additional processing. You would call the base class’s method and then do the extra processing in the derived class method.

Using object references as arguments and return values

You can pass an object reference as an argument to a method, or to any procedure defined to accept it. You can also use an object reference as the return value of a procedure. LotusScript passes objects by reference, not by value.

Keep these rules in mind when you pass an object reference to a procedure:

• You can pass a reference to a derived-class object to a procedure if the procedure parameter is declared as a variable of the base class.
• You cannot pass a reference to a base-class object if the procedure’s parameter is declared as a variable of the derived class.

Class Account
 Sub DepositMoney
   Print "In Account's DepositMoney sub."
 End Sub
End Class

Class CheckingAccount As Account
 Sub DepositMoney
   Print "In CheckingAccount's DepositMoney sub."
 End Sub
End Class

Sub PrintAccount(AccountArg As Account)
 Call AccountArg.DepositMoney
End Sub

Dim X As New Account
Call PrintAccount(X)      'Calls Account's DepositMoney method.

Dim Y As New CheckingAccount
' Calls CheckingAccount's DepositMoney sub. Y is legal as an
' argument to PrintAccount, because CheckingAccount is a
' derived class of Account.
Call PrintAccount(Y)

Using the Set statement with derived class objects

You can assign a variable that contains a reference to a derived-class object to a variable that can contain a reference to any of that object’s base classes. For example, you can assign the value of a variable of type CheckingAccount to a variable of type Account because the CheckingAccount class is derived from the Account class.

You cannot assign a reference in a variable of a base class to a variable that refers to an object of a derived class. For example, you cannot assign a reference in a variable of the Account class to a variable of the CheckingAccount class. If such an assignment were allowed, you might expect to be able to use CheckingAccount’s methods on the referenced object. But they might not exist, since the object might be of the Account class.

Class Account
 '...
End Class

Class CheckingAccount As Account
 '...
End Class

Dim X As New Account
Dim Y As New Account
Dim Z As New CheckingAccount

' Legal assignment of the contents of a base-class variable           ' to a base-class variable
Set X = Y

' Legal assignment of the contents of a derived-class variable        ' to a base-class variable
Set X = Z

' Cannot assign base-class variable to derived-class variable.
Set Z = X          ' Illegal

The last statement is illegal because, following the Set X = Z statement, the variable X references an object of the derived class, CheckingAccount. But the statement Set Z = X attempts to assign the value of a base class object reference variable, X, to a derived class object reference variable, Z.

See Also

Derived Classes
Base classes
Class statement

Glossary