Friend Class Rectangle
Public Length As Double
Public Height As Double
Function Assign() As Double
End Function
Function Perimeter() As Double
End Function
End Class
Therefore, in the body of the function, you can access a
member variable, you can call another method of the same class, or you can use
an external value as you see fit. When the function exits, make sure it returns
the appropriate value based on its type. Like the member variables, the methods can be accessed outside
of the class using the period operator. Here is an example:
Public Module Exercise
Friend Class Rectangle
Public Length As Double
Public Height As Double
Function Perimeter() As Double
Return (Length + Height) * 2
End Function
Function Area#()
Return Length * Height
End Function
End Class
Public Function Main() As Integer
Dim Recto As Rectangle
Recto = New Rectangle
Recto.Length = 42.58 : Recto.Height = 28.08
MsgBox("=-= Rectangle Characteristics =-=" & vbCrLf & _
"Length: " & vbTab & vbTab & Recto.Length & vbCrLf & _
"Height: " & vbTab & vbTab & Recto.Height & vbCrLf & _
"Perimeter: " & vbTab & Recto.Perimeter() & vbCrLf & _
"Area: " & vbTab & vbTab & Recto.Area())
Return 0
End Function
End Module
This would produce:
Like a sub procedure that is created as a method, a member
function of a class can be made private, public, or friendly. It follows the
exact same rules we reviewed early.
 Practical
Learning: Implementing the Methods of a Class
|
|
- Start Microsoft Visual Basic and create a Console Application named
DepartmentStore2
- In the Solution Explorer, right-click Module1.vb and click Rename
- Set the name to DepartmentStore.vb, press Enter, and accept to
rename the file
- To add two methods of the class, change the file as follows:
Module DepartmentStore
Public Class StoreItem
Public ItemNumber As Long
Public ItemName As String
Public UnitPrice As Double
Public Sub RegisterStoreItem()
ItemNumber = CLng(InputBox("=#= Department Store =#=" & vbCrLf & _
" --- Item Registration ---" & vbCrLf & _
vbCrLf & vbCrLf & vbCrLf & _
"Enter Item #", "Department Store"))
ItemName = InputBox("=#= Department Store =#=" & vbCrLf & _
" --- Item Registration ---" & vbCrLf & _
"Enter Item Name", "Department Store")
UnitPrice = CDbl(InputBox("=#= Department Store =#=" & vbCrLf & _
" --- Item Registration ---" & vbCrLf & _
vbCrLf & vbCrLf & vbCrLf & _
"Enter Unit Price", "Department Store"))
End Sub
Public Sub ShowItem()
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
End Sub
End Class
Public Function Main() As Integer
Dim dptStore As StoreItem = New StoreItem
dptStore.RegisterStoreItem()
dptStore.ShowItem()
Return 0
End Function
End Module
|
- Execute the program to test it
- Enter the item # as 740797
- Enter the item name as Pencil Skirt
- Enter the price as 25.75
- Close the form and return to your programming environment
Like regular procedures we have used so far, methods can have arguments. The rules are the same as we have applied
them so far. When you create a method, it has direct access to all regular
members of its class. This means that you don't have to create an argument
for a member variable of the same class. You would need an argument only
if an external value would be passed to the method.
Just as done for regular procedures, a method of a
class can be overloaded. To overload a method, create more than one method
with the same name. The methods with same names must have different rules
in their arguments:
- They can have different types of arguments. Here is an example:
Private Class EmployeeInformation
REM Contractor Registration
Private Sub Register(ByVal SalaryCategory As Integer)
End Sub
REM Full Time Employee Registration
Private Sub Register(ByVal HourlySalary As Double)
End Sub
End Class
|
- They can have a different number of arguments. Here is an example:
Private Class Geometry
REM The area of a square
Friend Function CalculateArea#(ByVal Side#)
Area# = Side * Side
End Function
REM The area of a rectangle
Friend Function CalculateArea#(ByVal Length#, ByVal Height#)
Area# = Length# * Height#
End Function
End Class
|
Any or both of these two rules must be respected.
|
The Shared Members of a Class
|
|
When you declare a variable of a class, you are said to have
created an instance of the class. This makes an object available so you can
initialize and use its member variables and methods as you see fit. Just as you can declare one instance of a class, in the same
way, you can declare as many instances as you judge it necessary. After
declaring various variables of the same class and initializing them, each
variable has and keeps its own values. Here is an example:
Public Module Exercise
Friend Class Rectangle
Public Length As Double
Public Height As Double
Public Function CalculatePerimeter#()
Return (Length + Height) * 2
End Function
Public Function CalcaulteArea#()
Return Length * Height
End Function
End Class
Public Function Main() As Integer
Dim RegistrationCard As New Rectangle
Dim Invoice As New Rectangle
RegistrationCard.Length = 24.55 : RegistrationCard.Height = 20.68
Invoice.Length = 8.5 : Invoice.Height = 11.65
MsgBox("==========================" & vbCrLf & _
"=-= Paper Registration Characteristics =-=" & vbCrLf & _
"Length: " & vbTab & vbTab & RegistrationCard.Length & vbCrLf & _
"Height: " & vbTab & vbTab & RegistrationCard.Height & vbCrLf & _
"Perimeter: " & vbTab & _
RegistrationCard.CalculatePerimeter#() & vbCrLf & _
"Area: " & vbTab & vbTab & _
RegistrationCard.CalcaulteArea#() & vbCrLf & _
"----------------------------------------------------" & vbCrLf & _
"=-= Paper Registration Characteristics =-=" & vbCrLf & _
"Length: " & vbTab & vbTab & Invoice.Length & vbCrLf & _
"Height: " & vbTab & vbTab & Invoice.Height & vbCrLf & _
"Perimeter: " & vbTab & Invoice.CalculatePerimeter#() & vbCrLf & _
"Area: " & vbTab & vbTab & Invoice.CalcaulteArea#() & vbCrLf & _
"==========================")
Return 0
End Function
End Module
This would produce:
In order to access the member variables of the above Rectangle
class, you must declare a variable of the class. The Visual Basic language provides an
alternative. You can declare a member variable so that you can access
it from anywhere in your code without primarily declaring a variable of the
class. In order to have such a member variable, you must explicitly create it as
shared.
To create a shared member
variable, type the Shared keyword on its left when declaring it. After
the shared member variable has been declared, you can use it like any other
member variable of that class, except that you don't need to declare an instance
of that class when you want to access that member variable. Here is an example:
Public Module Exercise
Friend Class Rectangle
Public Length As Double
Public Shared Height As Double
Public Function CalculatePerimeter#()
Return (Length + Height) * 2
End Function
Public Function CalcaulteArea#()
Return Length * Height
End Function
End Class
Public Function Main() As Integer
REM Notice that a Rectangle variable is not declared
Rectangle.Height = 20.68
MsgBox("Rectangle Characteristics" & vbCrLf & _
"Height:" & vbTab & vbTab & Rectangle.Height)
Return 0
End Function
End Module
This would produce:
Based on this, when creating a class, you will decide
whether you want a particular member variable to be shared or not. You can have
only one, two, more, or all member variables shared in a class. Experience and
your own goal will guide you.
Consider the following class:
Public Module Exercise
Friend Class Rectangle
Public Shared Length As Double
Public Shared Height As Double
Public Function CalculatePerimeter#()
Return (Length + Height) * 2
End Function
Public Function CalcaulteArea#()
Return Length * Height
End Function
End Class
Public Function Main() As Integer
REM Notice that a Rectangle variable is not declared
Rectangle.Height = 20.68
Rectangle.Length = 32.47
MsgBox("Rectangle Characteristics" & vbCrLf & _
"Length:" & vbTab & Rectangle.Length & vbCrLf & _
"Height:" & vbTab & Rectangle.Height)
Return 0
End Function
End Module
This would produce:
Like member variables, a method can be shared among
classes. In some cases, shared methods are more used than shared member
variables because a shared method allows performing an action on a
class without declaring an instance of that class. To create a shared method, type the Shared keyword
on the left of the Sub or the Function keyword. Here is an
example:
Here is an example:
Friend Class Rectangle
Shared Function CalculatePerimeter#()
Return (Length + Height) * 2
End Function
End Class
You can apply the access modifier on the method as we have
done so far. Here are examples:
Friend Class Rectangle
Public Shared Function CalculatePerimeter#()
End Function
Public Shared Function CalcaulteArea#()
End Function
End Class
Like a shared member variable, once a
method has been created as shared, it can be accessed directly from
anywhere. Remember that you would need to type the name of the class
before accessing the method. The name of the class allows you to
"qualify" the method. Here is an example:
Public Module Exercise
Friend Class Rectangle
Public Shared Length As Double
Public Shared Height As Double
Public Shared Function CalculatePerimeter#()
Return (Length + Height) * 2
End Function
Public Shared Function CalcaulteArea#()
Return Length * Height
End Function
End Class
Public Function Main() As Integer
REM Notice that a Rectangle variable is not declared
Rectangle.Height = 20.68
Rectangle.Length = 32.47
MsgBox("Rectangle Characteristics" & vbCrLf & _
"Length:" & vbTab & vbTab & Rectangle.Length & vbCrLf & _
"Height:" & vbTab & vbTab & Rectangle.Height & vbCrLf & _
"Perimeter: " & vbTab & Rectangle.CalculatePerimeter#() & vbCrLf & _
"Area: " & vbTab & vbTab & Rectangle.CalcaulteArea#())
Return 0
End Function
End Module
We have mentioned two techniques of accessing the members of
a class, one consisted of declaring a variable of the class, the other had to do
with Shared members. We know
already that the members of a class are made available to all other members of
the same class without being declared or qualified. Consider the following
class:
Public Class Triangle
Public Base As Double
Public Height As Double
Public Area As Double
Public Sub Display()
Dim Area As Double
Area = Base * Height / 2
End Sub
End Class
When the Area variable is used in the Display() method,
there are two variables available and named Area. It makes it confusing to know
what particular variable is being accessed. You can use a special member of a class that allows you to specify the member of a
class when accessing it. This member is called Me.
When using Me, you can access any member of a class within any method of the same
class. Here is an example:
Public Module Exercise
Public Class Triangle
Public Base As Double
Public Height As Double
Public Area As Double
Public Sub Display()
Dim Area As Double
' Using "this" to access the members of this class
Me.Base = 24.55
Me.Height = 20.75
' You cannot use this to access Area because Area
' is not a member of this class
Area = Me.Base * Me.Height / 2
MsgBox("Triangle Characteristics" & vbCrLf & _
"Base:" & vbTab & Me.Base & vbCrLf & _
"Height:" & vbTab & Me.Height & vbCrLf & _
"Area: " & vbTab & Area) ' Area is not a member of the Exercise class
End Sub
End Class
Public Function Main() As Integer
Dim tri As Triangle = New Triangle
tri.Display()
Return 0
End Function
End Module
This would produce:
There are rules you must follow when using Me:
- Me can never be declared: it is automatically implied
when you create a class
- Me cannot be used in a class A to access a member of class B
- Me cannot be used in a Shared method. The following program will not
compile because Me is used in the Display() method declared as a Shared
method:
Public Class Triangle
Public Base As Double
Public Height As Double
Public Area As Double
Public Shared Sub Display()
Dim Area As Double
' Using "this" to access the members of this class
Me.Base = 24.55
Me.Height = 20.75
' You cannot use this to access Area because Area
' is not a member of this class
Area = Me.Base * Me.Height / 2
MsgBox("Triangle Characteristics" & vbCrLf & _
"Base:" & vbTab & Me.Base & vbCrLf & _
"Height:" & vbTab & Me.Height & vbCrLf & _
"Area: " & vbTab & Area)
End Sub
End Class
|
|
Techniques of Initializing a Member Variable
|
|
In Lesson 2, we saw that
when you declare a variable, the compiler initializes its allocated memory with
a default value. Consider the following program:
Public Module Exercise
Private Class Square
Private Side As Double
Function CalculatePerimeter() As Double
Return Side * 4
End Function
Function CalculateArea() As Double
Return Side * Side
End Function
Public Sub ShowMessage()
MsgBox("Square Characteristics" & vbCrLf & _
"Side:" & vbTab & vbTab & FormatNumber(Side) & vbCrLf & _
"Perimeter:" & vbTab & _
FormatNumber(CalculatePerimeter()) & vbCrLf & _
"Area:" & vbTab & vbTab & FormatNumber(CalculateArea()))
End Sub
End Class
Public Function Main() As Integer
Dim sqr As Square = New Square
sqr.ShowMessage()
Return 0
End Function
End Module
This would produce:
Notice that this program indicates that the Side member
variable of the Square class was initialized with 0. This means that, like the
regular variables, the member variables of a class are initialized by the
compiler with default values that depend on the type of the variable. For
example, a numeric member variable is initialized with 0 while a string-based
variable is initialized with an empty string.
After adding a member variable to a class, instead of
relying on the default value assigned by the compiler, you can initialized it
with a value of your choice, depending on the type of the variable. You have
various alternatives.
Practical
Learning: Creating a Class
|
|
- Create a Console Application named
DepartmentStore3
- In the Solution Explorer, right-click Module1.vb and click Rename
- Set the name to DepartmentStore.vb, press Enter, and accept to
rename the file
- To create a new class, in the Solution Explorer, right-click
DepartmentStore3 -> Add -> Class...
- Set the Name to StoreItem and press Enter
- Change the file as follows:
Public Enum ItemCategory
Women
Men
Girls
Boys
Babies
Jewelry
Beauty
Bedroom
Miscellaneous
End Enum
Public Class StoreItem
Friend ItemNumber As Long
Friend Category As ItemCategory
Friend ItemName As String
Friend UnitPrice As Double
Public Sub ShowItem()
Dim StrCategory As String
Select Case Category
Case ItemCategory.Women
StrCategory = "Women"
Case ItemCategory.Men
StrCategory = "Men"
Case ItemCategory.Girls
StrCategory = "Girls"
Case ItemCategory.Boys
StrCategory = "Boys"
Case ItemCategory.Babies
StrCategory = "Babies"
Case ItemCategory.Jewelry
StrCategory = "Jewelry"
Case ItemCategory.Beauty
StrCategory = "Beauty"
Case ItemCategory.Bedroom
StrCategory = "Bedroom"
Case Else
StrCategory = "Miscellaneous"
End Select
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Category:" & vbTab & StrCategory & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
End Sub
End Class
|
- Save All
|
Initialization of a Member Variable
|
|
One way you can initialize a member variable is to assign it
the desired value when declaring it. Here is an example:
Public Module Exercise
Private Class Square
Private Side As Double = 48.25
Function CalculatePerimeter() As Double
Return Side * 4
End Function
Function CalculateArea() As Double
Return Side * Side
End Function
Public Sub Message()
MsgBox("Square Characteristics" & vbCrLf & _
"Side:" & vbTab & vbTab & FormatNumber(Side) & vbCrLf & _
"Perimeter:" & vbTab & _
FormatNumber(CalculatePerimeter()) & vbCrLf & _
"Area:" & vbTab & vbTab & FormatNumber(CalculateArea()))
End Sub
End Class
Public Function Main() As Integer
Dim sqr As Square = New Square
sqr.Message()
Return 0
End Function
End Module
This would produce:
Notice that, this time, the default value assigned to the
member variable applies. Instead of initializing a member variable when
declaring it, you can create a method that would be used to do this. Here is an
example:
Public Class Square
Private side As Double
Public Sub SetSide()
side = 48.25
End Sub
End Class
Such a method can also be used to initialize more than one
value. When you create a method used to initialize one or more member variables
of a class, if you want the initialization to apply, you must make sure that you
call that method first before calling other methods of the class.
Just as you can create a method to initialize the
member(s)
of a class, you can overload that method with different versions to perform
different initializations. Here are examples:
Public Module Exercise
Private Class Square
Private side As Double
Public Sub SetSide()
side = 48.25
End Sub
Public Sub SetSide(ByVal sd As Double)
side = sd
End Sub
Function CalculatePerimeter() As Double
Return Side * 4
End Function
Function CalculateArea() As Double
Return Side * Side
End Function
Public Sub Message()
MsgBox("Square Characteristics" & vbCrLf & _
"Side:" & vbTab & vbTab & FormatNumber(Side) & vbCrLf & _
"Perimeter:" & vbTab & _
FormatNumber(CalculatePerimeter()) & vbCrLf & _
"Area:" & vbTab & vbTab & FormatNumber(CalculateArea()))
End Sub
End Class
Public Function Main() As Integer
Dim sqr As Square = New Square
sqr.SetSide()
sqr.Message()
Dim sd As Double
sd = CDbl(InputBox("Enter Square Side: "))
sqr.SetSide(sd)
sqr.Message()
Return 0
End Function
End Module
Here an example of running the program:
Notice that, although the Square.Side member variable is
private, you cab call the SetSide() public method to initialize it before
displaying the characteristics of a square.
Practical
Learning: Initializing the Member Variables of a Class
|
|
- Change the StoreItem class as follows:
Public Enum ItemCategory
Women
Men
Girls
Boys
Babies
Jewelry
Beauty
Bedroom
Miscellaneous
End Enum
Public Class StoreItem
Friend ItemNumber As Long
Friend Category As ItemCategory
Friend ItemName As String
Friend UnitPrice As Double
Public Sub Initialize(ByVal Number As Long, _
ByVal Type As ItemCategory, _
ByVal Name As String, _
ByVal Price As Double)
ItemNumber = Number
Category = Type
ItemName = Name
UnitPrice = Price
End Sub
Public Sub ShowItem()
Dim StrCategory As String
Select Case Category
Case ItemCategory.Women
StrCategory = "Women"
Case ItemCategory.Men
StrCategory = "Men"
Case ItemCategory.Girls
StrCategory = "Girls"
Case ItemCategory.Boys
StrCategory = "Boys"
Case ItemCategory.Babies
StrCategory = "Babies"
Case ItemCategory.Jewelry
StrCategory = "Jewelry"
Case ItemCategory.Beauty
StrCategory = "Beauty"
Case ItemCategory.Bedroom
StrCategory = "Bedroom"
Case Else
StrCategory = "Miscellaneous"
End Select
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Category:" & vbTab & StrCategory & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
End Sub
End Class
|
- Access the DepartmentStore.vb file
- To use a StoreItem object, change the file as follows:
Public Module DepartmentStore
Public Function Main() As Integer
Dim Nbr As Long
Dim Classification As ItemCategory
Dim Description As String
Dim Value As Double
Dim Item As StoreItem
Nbr = 608432
Classification = ItemCategory.Jewelry
Description = "Silver 1/10-ct. T.W. Diamond Heart-Link Bracelet"
Value = 95.85
Item = New StoreItem
Item.Initialize(Nbr, Classification, Description, Value)
Item.ShowItem()
Return 0
End Function
End Module
|
- Execute the application to see the result
- Close the form and return to your programming environment
When you declare a variable of a class, a special
method must be called to initialize the members of that class. This method
is automatically provided for every class and it is called a constructor.
Whenever you create a new class, a constructor is automatically provided
to it. This particular constructor is called the default
constructor. You have the option of creating it or not. Although a constructor is created for your class, you can
customize its behavior or change it as you see fit.
The constructor of a class is called New and it is
created as a sub procedure. Here is an example:
Public Class Square
Public Sub New()
End Sub
End Class
Like every method, a constructor is equipped with
a body. In this body, you can access any of the member variables (or
method(s)) of the same class. Consider the following program:
Public Module Exercise
Private Class Square
Public Sub New()
MsgBox("Square Builder")
End Sub
End Class
Public Function Main() As Integer
Dim sq As Square = New Square
Return 0
End Function
End Module
When executed, it would produce:
This shows that, when a class has been instantiated,
its constructor is the first method to be called. For this reason, you can
use a constructor to initialize a class, that is, to assign default values
to its member variables. Based on this, instead of initializing the member
variable(s) of a class when initializing it or them, or instead of
creating a special method used to initialize the member variable(s) of a
class, you can use a constructor to do this. The advantage of a
constructor is that it doesn't need to be called: it is automatically
available whenever the class is instantiated.
Practical
Learning: Constructing a Class
|
|
- Create a Console Application named
DepartmentStore4
- In the Solution Explorer, right-click Module1.vb and click Rename
- Set the name to DepartmentStore.vb, press Enter, and accept to
rename the file
- To create a new class, in the Solution Explorer, right-click
DepartmentStore4 -> Add -> Class...
- Set the Name to StoreItem and click Add
- Change the file as follows:
Public Enum ItemCategory
Women
Men
Girls
Boys
Babies
Jewelry
Beauty
Bedroom
Miscellaneous
End Enum
Public Class StoreItem
Friend ItemNumber As Long
Friend Category As ItemCategory
Friend ItemName As String
Friend UnitPrice As Double
Public Sub New()
Me.ItemNumber = 0
Me.Category = ItemCategory.Miscellaneous
Me.ItemName = "Unknown"
Me.UnitPrice = 0D
End Sub
Public Sub ShowItem()
Dim StrCategory As String
Select Case Category
Case ItemCategory.Women
StrCategory = "Women"
Case ItemCategory.Men
StrCategory = "Men"
Case ItemCategory.Girls
StrCategory = "Girls"
Case ItemCategory.Boys
StrCategory = "Boys"
Case ItemCategory.Babies
StrCategory = "Babies"
Case ItemCategory.Jewelry
StrCategory = "Jewelry"
Case ItemCategory.Beauty
StrCategory = "Beauty"
Case ItemCategory.Bedroom
StrCategory = "Bedroom"
Case Else
StrCategory = "Miscellaneous"
End Select
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Category:" & vbTab & StrCategory & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
End Sub
End Class
|
- Access the DepartmentStore.vb file
- To use a StoreItem object, change the file as follows:
Public Module DepartmentStore
Public Function Main() As Integer
Dim Item As StoreItem
Item = New StoreItem
Item.ShowItem()
Return 0
End Function
End Module
|
- Execute the application to see the result
- Close the form and return to your programming environment
|
A Constructor With Argument(s)
|
|
In the previous section, we saw that there was always a
default constructor for a new class that you create; you just havce the option of
explicitly creating one or not. The default constructor as we saw it doesn't
take arguments: this is not a rule, it is simply assumed. Instead of a default
constructor, you may want to create a constructor that takes an argument. Here
is an example:
Private Class Square
Public Sub New(ByVal sd As Double)
End Sub
End Class
With this type of constructor, when you declare an instance
of the class, you can use this new constructor to initialize the class. Here is
an example:
Public Module Exercise
Private Class Square
Public Sub New(ByVal sd As Double)
MsgBox("Square Builder")
End Sub
End Class
Public Function Main() As Integer
Dim sqr As Square = New Square(38.64)
Return 0
End Function
End Module
If you create one constructor for your class and pass at
least one argument to that constructor, the automatic default constructor
created by the compiler disappears. This implies that if you declare an instance
of the class and use the default constructor to initialize it, you would receive
an error when you compile the program. Based on this, the following program will
produce an error:
Public Module Exercise
Private Class Square
Public Sub New(ByVal sd As Double)
MsgBox("Square Builder")
End Sub
End Class
Public Function Main() As Integer
Dim sqr As Square = New Square ' The default constructor is not available
Return 0
End Function
End Module
If you still want to use the default constructor in a class
after creating a constructor that takes at least one argument, you must
explicitly create that default constructor.
Practical
Learning: Constructing a Class
|
|
- To pass arguments to a constructor, change the file as follows:
Public Enum ItemCategory
Women
Men
Girls
Boys
Babies
Jewelry
Beauty
Bedroom
Miscellaneous
End Enum
Public Class StoreItem
Friend ItemNumber As Long
Friend Category As ItemCategory
Friend ItemName As String
Friend UnitPrice As Double
Public Sub New(ByVal Number As Long, _
ByVal Type As ItemCategory, _
ByVal Name As String, _
ByVal Price As Double)
ItemNumber = Number
Category = Type
ItemName = Name
UnitPrice = Price
End Sub
Public Sub ShowItem()
Dim StrCategory As String
Select Case Category
Case ItemCategory.Women
StrCategory = "Women"
Case ItemCategory.Men
StrCategory = "Men"
Case ItemCategory.Girls
StrCategory = "Girls"
Case ItemCategory.Boys
StrCategory = "Boys"
Case ItemCategory.Babies
StrCategory = "Babies"
Case ItemCategory.Jewelry
StrCategory = "Jewelry"
Case ItemCategory.Beauty
StrCategory = "Beauty"
Case ItemCategory.Bedroom
StrCategory = "Bedroom"
Case Else
StrCategory = "Miscellaneous"
End Select
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Category:" & vbTab & StrCategory & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
End Sub
End Class
|
- Access the DepartmentStore.vb file and change it as follows:
Public Module DepartmentStore
Public Function Main() As Integer
Dim Nbr As Long
Dim Classification As ItemCategory
Dim Description As String
Dim Value As Double
Dim Item As StoreItem
Nbr = 759470
Classification = ItemCategory.Men
Description = "Multistriped Organic Cotton Dress Shirt"
Value = 35.5
Item = New StoreItem(Nbr, Classification, Description, Value)
Item.ShowItem()
Return 0
End Function
End Module
|
- Execute the application to see the result
- Close the form and return to your programming environment
A constructor is the primary method of a class. It allows
the programmer to initialize a variable of a class when the class is
instantiated. A constructor that plays this role of initializing an instance of
a class is also called an instance constructor. Most of the time, you don't
need to create a constructor, since one is automatically provided to any class
you create. Sometimes though, as we have seen in some classes, you need to create
your own constructor as you judge it necessary and sometimes, a single constructor
may not be sufficient. For example, when creating a class, you may decide, or
find out, that there must be more than one way for a user to initialize a
variable.
Like any other method, a constructor can be overloaded. In
other words, you can create a class and give it more than one constructor. The
same rules used on overloading regular methods also apply to constructors: the
different constructors must have different number of arguments or different
types of arguments.
Practical
Learning: Overloading a Constructor
|
|
- Access the StoreItem.vb file
- To overload the constructor, change the file as follows:
Public Enum ItemCategory
Women
Men
Girls
Boys
Babies
Jewelry
Beauty
Bedroom
Miscellaneous
End Enum
Public Class StoreItem
Friend ItemNumber As Long
Friend Category As ItemCategory
Friend ItemName As String
Friend ItemSize As String
Friend UnitPrice As Double
REM Default Constructor, used to initialize an unidentified object
Public Sub New()
Me.ItemNumber = 0
Me.Category = ItemCategory.Miscellaneous
Me.ItemName = "Unknown"
Me.ItemSize = "Unknown or Fits All"
Me.UnitPrice = 0D
End Sub
REM This constructor is for items without size (jewelry, beauty, etc)
Public Sub New(ByVal Number As Long, _
ByVal Type As ItemCategory, _
ByVal Name As String, _
ByVal Price As Double)
Me.ItemNumber = Number
Me.Category = Type
Me.ItemName = Name
Me.UnitPrice = Price
End Sub
REM This constructor is used to identify an item to wear
Public Sub New(ByVal Number As Long, _
ByVal Type As ItemCategory, _
ByVal Name As String, _
ByVal Size As String, _
ByVal Price As Double)
Me.ItemNumber = Number
Me.Category = Type
Me.ItemName = Name
Me.ItemSize = Size
Me.UnitPrice = Price
End Sub
REM This method is used to display a description of an item
REM The caller will determine whether the item has a size or not
Public Sub ShowItem(ByVal HasSize As Boolean)
Dim StrCategory As String
Select Case Category
Case ItemCategory.Women
StrCategory = "Women"
Case ItemCategory.Men
StrCategory = "Men"
Case ItemCategory.Girls
StrCategory = "Girls"
Case ItemCategory.Boys
StrCategory = "Boys"
Case ItemCategory.Babies
StrCategory = "Babies"
Case ItemCategory.Jewelry
StrCategory = "Jewelry"
Case ItemCategory.Beauty
StrCategory = "Beauty"
Case ItemCategory.Bedroom
StrCategory = "Bedroom"
Case Else
StrCategory = "Miscellaneous"
End Select
If HasSize = True Then
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Category:" & vbTab & StrCategory & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Size:" & vbTab & vbTab & ItemSize & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
Else
MsgBox("=-= Department Store =-=" & vbCrLf & _
"--- Store Inventory ---" & vbCrLf & _
"Item #:" & vbTab & vbTab & ItemNumber & vbCrLf & _
"Category:" & vbTab & StrCategory & vbCrLf & _
"Item Name:" & vbTab & ItemName & vbCrLf & _
"Unit Price:" & vbTab & FormatCurrency(UnitPrice), _
MsgBoxStyle.OkOnly Or MsgBoxStyle.Information, _
"Department Store")
End If
End Sub
End Class
|
- Access the DepartmentStore.vb file and change it as follow:
Public Module DepartmentStore
Public Function Main() As Integer
Dim Nbr As Long
Dim Classification As ItemCategory
Dim Description As String
Dim Size As String
Dim Value As Double
Dim Item As StoreItem
REM Using the default constructor
Item = New StoreItem
Item.ShowItem(True)
Nbr = 608432
Classification = ItemCategory.Jewelry
Description = "Silver 1/10-ct. T.W. Diamond Heart-Link Bracelet"
Value = 95.85
REM Using the constructor that takes 4 arguments
Item = New StoreItem(Nbr, Classification, Description, Value)
Item.ShowItem(False)
Nbr = 437876
Classification = ItemCategory.Women
Description = "Crinkled Georgette Dress"
Size = "Medium"
Value = 42.95
REM Using the constructor that takes 5 arguments
REM after initialing a Women object
Item = New StoreItem(Nbr, ItemCategory.Women, _
Description, Size, Value)
Item.ShowItem(True)
REM Using the constructor that takes 5 arguments
REM Directly initialing the constructor
Item = New StoreItem(790475, ItemCategory.Men, _
"New Wool Comfort Pants", "36x33", 38.75)
Item.ShowItem(True)
REM Using the constructor that takes 5 arguments
REM Initialing the values in random order
Item = New StoreItem(Type:=ItemCategory.Women, _
Size:="9 1/2 W", _
Price:=35.5, _
Name:="Modest Dress Heels", _
Number:=487046)
Item.ShowItem(True)
Return 0
End Function
End Module
|
- Execute the application to see the result:
- Close the form and return to your programming environment
|
No comments:
Post a Comment