Earlier, we defined a House class with its properties. Unlike a property, a method must display parentheses on this right side to differentiate it from a property. An example would be:

House
[
      Address
      TypeOfHouse
      NumberOfBedrooms
      NumberOfBathrooms
      HasIndoorGarage
      LivingRoomCoveredWithCarpet
      KitchenHasIslandStove
      ProtectFromOutside()
]

When an object has a method, to access that method, type the name of the object, followed by a period, followed by the name of the method, and followed by parentheses. For example, if you have a House object named Langston and you want to ask it to protect its inside from outside rain, you would type:

Langston.ProtectFromOutside()

This is also referred to as calling a method.

1. Start Microsoft Excel
2. From the resources that accompany these lessons, open the gdcs1 project
3. To open Microsoft Visual Basic, on the Ribbon, click Developer and, in the Code section, click Visual Basic:
    
   
4. Right-click the form and click View Code

When asked to perform an action, a method may need one or more values to work with. If a method needs a value, such a value is called an argument. While a certain method may need one argument, another method would need more than one. The number of arguments of a method depends on its goal. The arguments of a method are provided in parentheses.

Suppose you have a House object and you want it to protect what is inside. There may be different reasons why the inside needs to be protected: may be from the rain, may be from the windy dust, may be at night time from too much light that prevents from sleeping, etc. Based on this, you may have to provide additional information to indicate why or how the inside should be protected. For this reason, when such a method is called, this additional information must be provided, in the parentheses of the method. Here is an example:

House
[
      Address
      TypeOfHouse
      NumberOfBedrooms
      NumberOfBathrooms
      HasIndoorGarage
      LivingRoomCoveredWithCarpet
      KitchenHasIslandStove
      ProtectFromOutside(Reason)
]

As mentioned above, a method can be created to take more than one argument. In this case, the arguments are separated with commas. Here is an example:

House
[
      Address
      TypeOfHouse
      NumberOfBedrooms
      NumberOfBathrooms
      HasIndoorGarage
      LivingRoomCoveredWithCarpet
      KitchenHasIslandStove
      ProtectFromOutside(Reason, WhenToProtect)
]

The arguments are used to assist the object with performing the intended action. Once a method has been created, it can be used. Once again, using a method is referred to as calling it. If a method takes one argument, when calling it, you must provide a value for the argument, otherwise the method would not work. 

To call a method that takes an argument, type the name of the method followed by the opening parenthesis “(“, followed by the value that will be the argument, followed by a closing parenthesis “)”. The argument you pass can be a regular constant value or it can be the name of another object.

If the method is taking more than one argument, to call it, type the values for the arguments, in the exact order indicated, separated from each other by a comma.

We have mentioned that, when calling a method that takes an argument, you must supply a value for the argument. There is an exception. Depending on how the method was created, it may be configured to use its own value if you fail, forget, or choose not, to provide one. This is known as the default argument. Not all methods follow this rule.

If a method that takes one argument has a default value for it, then you don't have to supply a value when calling that method. Such an argument is considered optional.

If a method takes more than one argument, some argument(s) may have default values while some others do not. The arguments that have default values can be used and you don't have to supply them.

We will mention default arguments when we come to a method that takes some.

On a form that has many controls, at one particular time, only one control can receive input from the user. The control that is currently receiving input or actions from the user is said to have focus.

To give focus to a control, the user can click the intended control or press Tab a few times until the control receives focus. To programmatically give focus to a control, type the name of the control, followed by the period operator, followed by the SetFocus method. An example would be:

Private Sub Example()
    txtAddress.SetFocus
End Sub

In previous lessons and sections, we saw that an object was made of properties and methods. We also saw how to access a property of an object. For example, imagine you have a House class defined as follows:

House
[
      Address
      TypeOfHouse
      NumberOfBedrooms
      NumberOfBathrooms
      HasIndoorGarage
      LivingRoomCoveredWithCarpet
      KitchenHasIslandStove
      ProtectFromOutside()
]

If you have an object named Camden and that is of type House. To access some of its properties, you would use code as follows:

Camden.Address
Camden.TypeofHouse

If you are working inside of a method of the class, for example if you are working in the body of the ProtectFromOutside method, you can also access the properties the same way, this time without the name of the object. This could be done as follows:

ProtectFromOutside()
    Address
    TypeofHouse
    NumberOfBedrooms
    NumberOfBathrooms
End

When you are accessing a member of a class inside of one of its own methods, you can precede that member with the Me object. You must include the period operator between Me and the member of the class. Here is an example:

ProtectFromOutside()
    Me.Address
    Me.TypeofHouse
    Me.NumberOfBedrooms
    Me.NumberOfBathrooms
End

Remember that the Me object is used to access the members of an object while you are inside of another member of the object.

We have seen that you can use the name of an object to access its members. Here is an example:

Camden.Address
Camden.TypeOfHouse
Camden.NumberOfBedrooms
Camden.NumberOfBathrooms
Camden.HasIndoorGarage

Instead of using the name of the object every time, you can start a section with the With keyword followed by the name of the object. In another line, end the section with the End With expression:

With Camden
    
End With

Between the With and the End With lines, to access a member of the class that the object is built from, type a period followed by the desired member. This would be done as follows:

With Camden
    .Address
    .TypeOfHouse
    .NumberOfBedrooms
    .NumberOfBathrooms
    .HasIndoorGarage
End With

As you access a member, you can perform on it any action you judge necessary.