Visual Basic.NET How to Program (PDF)

Chapter 8 Object-Based Programming 327
inherit method Finalize and can override it to free resources specific to those classes.
The overridden method is called before garbage collection occurs—however, we cannot
determine exactly when this method is called, because we cannot determine exactly when
garbage collection occurs. We discuss method Finalize in greater detail in Chapter 9,
when we discuss inheritance.
8.11 Shared Class Members
Each object of a class has its own copy of all the instance variables of the class. However,
in certain cases, all class objects should share only one copy of a particular variable. A
Shared class variable is such a variable; a program contains only one copy of this variable
in memory, no matter how many objects of the variable’s class have been instantiated. A
Shared class variable represents class-wide information—all class objects share the same
piece of data. The declaration of a Shared member begins with the keyword Shared.
In Visual Basic, programmers can define what is known as a shared constructor, which
is used only to initialize Shared class members. Shared constructors are optional and
must be declared with the Shared keyword. Normally, Shared constructors are used
when it is necessary to initialize a Shared class variable before any objects of that class
are instantiated. Shared constructors are called before any Shared class members are
used and before any class objects are instantiated.
We now employ a video-game example to explain the need for Shared class-wide data.
Suppose we have a video game in which CMartians attack with other space creatures. Each
CMartian tends to be brave and willing to attack other space creatures when the CMartian
is aware that there are at least four other CMartians present. If there are fewer than
a total of five CMartians present, each CMartian becomes cowardly. For this reason,
each CMartian must know the martianCount. We could endow class CMartian with
martianCount as instance data. If we were to do this, then every CMartian would have
a separate copy of the instance data, and, every time we create a CMartian, we would have
to update the instance variable martianCount in every CMartian. The redundant copies
waste space, and the updating of those copies is time-consuming. Instead, we declare martianCount
to be Shared so that martianCount is class-wide data. Each CMartian
can see the martianCount as if it were instance data of that CMartian, but Visual Basic
maintains only one copy of the Shared martianCount to save space. We also save time,
in that the CMartian constructor increments only the Shared martianCount. Because
there is only one copy, we do not have to increment separate copies of martianCount for
each CMartian object.
Performance Tip 8.2
When a single copy of the data will suffice, use Shared class variables to save storage. 8.2
Although Shared class variables might seem like global variables in C and C++
(variables that can be referenced directly by name in any C function or C++ class or method
in a program), they are not the same thing. Shared class variables have class scope. A
class’s Public Shared members can be accessed through the class name using the dot
operator (e.g., className.sharedMemberName). A class’s Private Shared class
members can be accessed only through methods of the class. Shared class members are
available as soon as the class is loaded into memory at execution time; like other variables