Smalltalk and Object Orientation: an Introduction - Free

These messages are sent automatically by the dependency mechanism in response to a change d
message being sent to the object, on which the object they are sent to depends. That is, if ObjectA is
sent a changed message, one of the above will be sent to ObjectB. Which message appears to be sent
depends on which method has been defined in ObjectB. This is because the method calling process is
implemented such that the first message sent to the object will be update:with:from:. Unless this
is overwritten, this method calls update:with:. In turn the update:with: method calls the
update: method. This method by default does nothing. Therefore, if you define any one of these three
methods, that method will be executed.
This means that the developer can decide how much information the dependent object wishes to
work with. The parameter values that the developer can work with are:
• anAspect the value used for anAspect in the changed message or nil.
• aParameter the value used for aParameter in the changed message or nil.
• anObject the object which received the changed message.
25.3.8 Extending the dependency example
This section will provide an example of how the dependency mechanism works. We shall use the
DataObject and DependentObject classes defined back in section 25.3.4.
The first thing we shall do is to define a couple of instance var iables in DataObject. These
variables will be age, name and address. For example:
Object subclass: #DataObject
instanceVariableNames: 'age name address '
classVariableNames: ''
poolDictionaries: ''
category: 'dependency demo'
Next we shall define an updater method for each of these instance variables. For example, in Figure
25.5, we have defined a new method age: which sets the age instance variable. It then informs the
object that we have changed its age and that this fact should be passed onto its dependents (i.e. self
changed: #age). This is a typical usage of a changed message. That is, it is sent to self informing
self about the change which has taken place. It is very poor style to have one object send an inst ance
of DataObject the message age:, followed by the changed message!
Next we shall define how an instance of DependentObject should respond to the change in a
DataObject. That is we will define one of the update methods. The method we will define is the
update: method. This method is placed in a protocol called updating. The actual method is illustrated
in Figure 25.6. As this is just a simple example, all that this does is to print a string in the
Transcript which illustrates the change which has occurred to a DataObject instance.
Figure 25.5: Defining an updater for age
We are now ready to try out this simple example. To do this we will use the source code previously
typed into the Transcript (minus the last inspect statement). To this we will add three statements which
set the dataObject’s age, name and address:
211