Visual Basic.NET How to Program (PDF)

Chapter 8 Object-Based Programming 305
Note that the program declares instance variables mHour, mMinute and mSecond
as Private. Instance variables declared Private are not accessible outside the class in
which they are defined. The class’s clients are not concerned with the actual data representation
of that class. For example, the class could represent the time internally as the number
of seconds that have elapsed since the previous midnight. Suppose this representation
changes. Clients still are able to use the same Public methods and obtain the same results
(Return values) without becoming aware of the change in internal representation. In this
sense, the implementation of a class is said to be hidden from its clients.
Software Engineering Observation 8.5
Information hiding promotes program modifiability and simplifies the client’s perception of
a class. 8.5
Software Engineering Observation 8.6
Clients of a class can (and should) use the class without knowing the internal details of how
the class is implemented. If the class implementation is changed (to improve performance,
for example), provided that the class’s interface remains constant, the class clients’ source
code need not change. This makes it much easier to modify systems. 8.6
In this program, the CTime constructor initializes the instance variables to 0 (i.e., the
universal time equivalent of 12 AM) to ensure that the object is created in a consistent state
(i.e., all instance variable values are valid). The instance variables of a CTime object
cannot store invalid values, because the constructor (which calls SetTime) is called when
the CTime object is created. Method SetTime scrutinizes subsequent attempts by a client
to modify the instance variables.
Normally, instance variables are initialized in a class’s constructor, but they also can
be initialized when they are declared in the class body. If a programmer does not initialize
instance variables explicitly, the compiler initializes them. When this occurs, the compiler
sets primitive numeric variables to 0, Booleans to False and references to Nothing).
Methods ToUniversalString and ToStandardString take no arguments
because, by default, these methods manipulate the instance variables of the particular
CTime object for which they are invoked. This makes method calls more concise than
conventional function calls in procedural programming. It also reduces the likelihood of
passing the wrong arguments, the wrong types of arguments or the wrong number of
arguments.
Software Engineering Observation 8.7
The use of an object-oriented programming approach often simplifies method calls by reducing
the number of parameters that must be passed. This benefit of object-oriented
programming derives from the fact that encapsulation of instance variables and methods
within an object gives the object’s methods the right to access its instance variables. 8.7
Classes simplify programming, because the client (or user of the class object) need be
concerned only with the Public operations encapsulated in the object. Usually, such
operations are designed to be client-oriented, rather than implementation-oriented. Clients are
neither aware of, nor involved in, a class’s implementation. Interfaces change less frequently
than do implementations. When an implementation changes, implementation-dependent code
must change accordingly. By hiding the implementation, we eliminate the possibility that
other program parts will become dependent on the class-implementation details.