CLASS INSTANTIATION DETAILS

When you declare a reference variable, Visual Basic allocates space for the reference. Initially, that reference is set to Nothing, so it doesn’t point to anything and no memory is allocated for an actual object.

You create an object by using the New keyword. Creating an actual object is called instantiating the class.

The following code shows a simple object declaration and instantiation. The first line declares the reference variable. The second line makes the variable point to a new Employee object.

Dim emp As Employee ' Declare a reference to an Employee object.
emp = New Employee  ' Make a new Employee object and make emp point to it.

Visual Basic also enables you to declare and initialize a variable in a single statement. The following code shows how to declare and initialize an object reference in one statement:

Dim emp As Employee = New Employee ' Declare and instantiate an object.

Visual Basic lets you declare a variable to be of a new object type, as shown in the following statement. This version has the same effect as the preceding one but is slightly more compact.

Dim emp As New Employee ' Declare and instantiate an object.

Both of these versions that define and initialize an object in a single statement ensure that the variable is initialized right away. They guarantee that the object is instantiated before you try to use it. If you place these kinds of declarations immediately before the code where the object is used, they also make it easy to see where the object is defined.

Although you can declare and instantiate a reference variable separately, value type variables are allocated when they are declared. Because structures are value types, when you declare one you also allocate space for its data, so you don’t need to use the New keyword to initialize a structure variable.

Both classes and structures can provide special subroutines called constructors. A constructor is a special subroutine named New that Visual Basic calls when a new instance of the class or structure is created. The constructor can perform initialization tasks to get the new object ready for use.

A constructor can optionally take parameters to help in initializing the object. For example, the Person class shown in the following code has a constructor that takes as parameters first and last names and saves them in the control’s FirstName and LastName variables:

Public Class Person
   Public FirstName As String
   Public LastName As String
 
   Public Sub New(ByVal first_name As String, ByVal last_name As String)
       FirstName = first_name
       LastName = last_name
   End Sub
End Class

The following code shows how a program might use this constructor to create a new Person object:

Dim author As New Person("Rod", "Stephens")

You can overload the New method just as you can overload other class methods. The different overloaded versions of the constructor must have different parameter lists so that Visual Basic can decide which one to use when it creates a new object.

The following code shows a Person class that provides two constructors. The first takes two strings as parameters and copies them into the object’s FirstName and LastName values. The second version takes no parameters and invokes the first constructor to set the object’s FirstName and LastName values to <unknown>.

Public Class Person
    Public FirstName As String
    Public LastName As String
 
    Public Sub New(first_name As String, last_name As String)
        FirstName = first_name
        LastName = last_name
    End Sub
 
    Public Sub New()
        Me.New("<unknown>", "<unknown>")
    End Sub
End Class

The following code uses each of these constructors:

Dim person1 As New Person                    ' <unknown> <unknown>.
Dim person2 As New Person("Olga", "O'Toole") ' Olga O'Toole.

If you do not provide any constructors for a class, Visual Basic allows the program to use the New keyword with no parameters. If you create any constructor, however, Visual Basic does not allow the program to use this default empty constructor (without parameters) unless you build one explicitly. For example, if the previous version of the Person class did not include a parameterless constructor, the program could not use the first declaration in the previous code that doesn’t include any parameters.

You can use this feature to ensure that the program assigns required values to an object. In this case, it would mean that the program could not create a Person object without assigning FirstName and LastName values.

If you want to allow an empty constructor in addition to other constructors, an alternative is to create a single constructor with optional parameters. The following code shows this approach. With this class, the program could create a new Person object, passing its constructor zero, one, or two parameters.

Public Class Person
    Public FirstName As String
    Public LastName As String
 
    Public Sub New(
     Optional first_name As String = "<unknown>",
     Optional last_name As String = "<unknown>")
        FirstName = first_name
        LastName = last_name
    End Sub
End Class

When you use a class’s parameterless constructor to create an object, you can also include a With clause to initialize the object’s properties. The following code uses the Person class’s parameterless constructor to make a new Person object. The With statement then sets values for the object’s FirstName and LastName values.

Dim author As New Person() With {.FirstName = "Rod", .LastName = "Stephens"}