Smalltalk and Object Orientation: an Introduction - Free

• A method should only send messages to a limited set of objects. This promotes
maintainability and comprehensibility and increases the modularity of the method.
• Have you used accessor methods for instance variable access? This is known as variable-free
programming. This can greatly insulate the method from changes in how the object holds
information.
• Is t he behaviour encapsulated by the method intended for public or private (to the object)
use? If it is a mixture of the two, then the method should be decomposed into two or more
methods. The private code should be placed in a method which is defined within a private
protocol (see below). This indicates to developers that the method is not intended for external
use.
• Does the method rely more on the behaviour of other objects than on its own object (that is,
a series of messages is being sent to some object(s ) other than “self”)? If so, the method may
be better placed in another object (or objects).
This last point is worth considering in slightly more detail. The series of messages in such a method
may be better placed in a method in the class of the receive r object. This is because it is really
describing behaviour associated with that object. By placing it with the receiver object’s class, all
modifications to the behaviour of the receiver are encapsulated in that object. In addition, this behaviour
may be useful to other objects, by encoding it within the receiver’s class, they can all gain access to that
behaviour (rather than having to duplicate it in a number of places). It is not easy to get good method
level code reuse with poorly placed code. To do th is most messages should be sent to self. Note: This is
probably one of the hardest things to do well in object oriented programming. However, if done
correctly it can pay very high dividends.
24.4.3 Class methods versus instance methods
It may at first seem unclear what should normally go in a class (side) method as opposed to what should
go in an instance (side) method when defining a new class. After all they are both defined in the class!
However, it is important to remember that one defines the behaviour of th e instance and the other the
behaviour of the class (the class side methods). The class side methods should only perform one of the
following roles:
Instance creation. This role is very important as it is often used to initialize instance variables of an
object to appropriate values. For example, it is quite common to see a class side method called new
used to send the message initialize to a new instance.
Class variable access. See below for a discussion of this role.
Inquiries about the class. Such methods answer with generally useful objects, frequently derived from
class variables. For example, they may return the number of instances of this object created.
Instance management. To control the number of instances created. For example, some classes only
allow one single instance of that class to be created.
A documentation role. Class methods solely for documentation are sometimes used. Generally the
class comment is a better place for this information unless such a facility is not available e.g. in
Smalltalk V.
Examples. Occasionally class methods are used to provide helpful examples which are aimed at
explaining the operation of a class. This is good practice.
Testing. Class side methods can be used to support testing of an instance of a class. Such meth ods can
be used to create an instance, perform some operation and then compare the result with a known
value. If the values are different an error can be reported. This is a very useful way of providing
regression tests.
Support for one of the above.
Anything else should be performed by an instance method.
24.4.4 Class instance creation methods
It is quite common to want to redefine the way in which a new instance is created. This can be because
you wish to:
201