Class MyFirstClass
  Private m_sMyPrivateString
  Private m_oMyPrivateObject
  Public m_iMyPublicInteger
End Class

Hence, the private fields' m_sMyPrivateString and m_oMyPrivateObject will be accessible only from within the class methods, properties, and subroutines. The public field m_iMyPublicInteger will be accessible from any part of the code that will have a reference to an instance of the MyFirstClass class; and it can also allow partial or full access to private fields, by implementing public properties.

A property is a special case in VBScript; it is the only code structure that allows for a duplicate identifier. That is, one can have a Property Get and a Property Let procedure (or Property Set, to be used when the member field actually is meant to store a reference to an instance of another class) with the same identifier. Note that Property Let and Property Set accept a mandatory argument. For example:

Class MyFirstClass
  Private m_sMyPrivateString
  Private m_oMyPrivateObject
   Public m_iMyPublicInteger

  Property Get MyPrivateString()
    MyPrivateString = m_sMyPrivateString
  End Property

  Property Let MyPrivateString(ByVal str)
    m_sMyPrivateString = str
  End Property
  
  Property Get MyPrivateObject()
    Set MyPrivateObject = m_oMyPrivateObject
  End Property

  Private Property Set MyPrivateObject(ByRef obj)
    Set m_oMyPrivateObject = obj
  End Property
End Class

The public field m_iMyPublicInteger can be accessed from any code block, so defining a getter and setter (as properties are often referred to) for such a field is optional. However, it is a good practice to define fields as private and explicitly provide access through public properties. For fields that are for exclusive use of the class members, one can define the properties as private. In such a case, usually, the setter (Property Let or Property Set) would be defined as private, while the getter (Property Get) would be defined as public. This way, one can prevent other code components from making changes to the internal fields of the class to ensure data integrity and validity.

Set obj = New MyFirstClass

The Initialize event takes place at the time the object is created. It is possible to add code that we wish to execute every time an object is created. So, now define the standard private subroutine Class_Initialize, sometimes referred to (albeit only by analogy) as the constructor of the class. If implemented, the code will automatically be executed during the Initialize event. For example, if we add the following code to our class:

Private Sub Class_Initialize
  MsgBox TypeName(me) & " started"
End Sub

Now, every time the Set obj = New MyFirstClass statement is executed, the following message will be displayed:

Set obj = Nothing

The Finalize event takes place at the time when the object is removed from memory. It is possible to add code that we wish to execute, every time an object is disposed of. If so, then define the standard private subroutine Class_Terminate, sometimes referred to (albeit only by analogy) as the destructor of the class. If implemented, the code will automatically be executed during the Finalize event. For example, if we add the following code to our class:

Private Sub Class_Terminate
  MsgBox TypeName(me) & " ended"
End Sub

Now, every time the Set obj = Nothing statement is executed, the following message will be displayed:

'Declare variables
Dim obj, var

'Calling MyPublicFunction
obj.MyPublicFunction("Hello")

'Retrieving the value of m_sMyPrivateString
var = obj.MyPrivateString

'Setting the value of m_sMyPrivateString
obj.MyPrivateString = "My String"

Note that the usage of the public members is done by using the syntax obj.<method or property name>, where obj is the variable holding the reference to the object of class. The dot operator (.) after the variable identifier provides access to the public members of the class. Private members can be called only by other members of the class, and this is done like any other regular function call.

Public Default Function MyPublicFunction(ByVal str)
  MsgBox TypeName(me) & " – Public Func: " & str
  MyPublicFunction = 0
End Function

Now, the following statements would invoke the MyPublicFunction method implicitly:

Set obj = New MyFirstClass

obj("Hello")

This is exactly the same as if we called the MyPublicFunction method explicitly:

Set obj = New MyFirstClass

obj.MyPublicFunction("Hello")

In general, the reason is linked to the fact that UFT uses a wrapper on top of WSH, which actually executes the VBScript (VBS 5.6) code. Therefore, in order to create instances of such a custom class, we need to use a kind of constructor function that will perform the New operation from the proper memory namespace. Add the following generic constructor to your function library:

Function Constructor(ByVal sClass)
  Dim obj
  
  On Error Resume Next  
  
  'Get instance of sClass
  Execute "Set obj = New [" & sClass & "]"
  If Err.Number <> 0 Then
    Set obj = Nothing    
    Reporter.ReportEvent micFail, "Constructor", "Failed to create an instance of class '" & sClass & "'."
  End If
  
  Set Constructor = obj
End Function

We will then instantiate the object from the UFT Action, as follows:

Set obj = Constructor("MyFirstClass")

Consequently, use the object reference in the same fashion as seen in the previous line of code:

obj.MyPublicFunction("Hello")