Smalltalk and Object Orientation: an Introduction - Free

Object 1
name: 'John'
age: 31
Class: person
Instance variables:
name, age
Methods: birthday
name: 'Peter'
age: 65
Object 4
name: 'Dave'
age: 27
name: 'Chris'
age: 39
Object 2 Object 3
Figure 6.1: Multiple instance variables but a single method
In Figure 6.1 there are four instance of the class Person. Each instance contains copies of the
instance variable definitions for name and age. Thus enabling them to have their own values for these
instance variables. In contrast, each instance references the single definition for the method birthday
which is held by the class.
6.3.4 Classes and inheritance
It is through classes that an object can inherit facilities from other types of objects. T hat is, a subclass
inherits properties from its superclass. For example, in the Person definition above, we stated that
Person was a subclass of Object. Therefore, Person inherits all the methods and instance
variables etc. which were defined in Object (except those that were overwritten in Person). Thus,
subclasses are used to refine the behavior and data structures of a superclass. It should be noted that
Smalltalk supports single inheritance while some of the object oriented languages (most notably C++)
support multiple inheritance. Multiple inheritance is where a subclass can inherit from more than one
superclass. However, difficulties can arise when attempting to determine where different methods will
be executed.
6.3.4.1 An example of inheritance
To illustrate how single inheritance works consider Figure 6.2. We will assume that we have three
classes called Class1, Class2 and Class3. Class1 is a subclass of Object, Class2 is a
subclass of Class1 and Class3 is a subclass of Class2.
When an instance of Class3 is created, it contains all the instance variables defined in classes 1 to
3 and class Object. If any instance variable possesses the same name as an instance variable in a
higher class, then only one instance variable of that name will be created. We do not need to consider
which one is created as they are both instance variables which can take any value (Smalltalk is not
strongly typed remember!).
When we have an instance of Class3 we can send it a message requesting that a particular method
is executed. Remember that methods are held by classes and not by instances. This means that the
system will first find the class of the instance (in this case Class3) and search that class for the
required method. If the method is fo und, then it is executed and the search stops. However, if the
method is not found, then the system will search Class3’s immediate super class; in this case
Class2. This process is repeated until the method is found. Eventually, the search thr ough the
superclasses may reach the class Object (which is the root class in the Smalltalk system). If the
required method is not found here, then the search process terminates and the
doesNotUnderstand: method in the class Object is executed instead. This method causes an
exception to be raised stating that the message sent to the original instance is not understood.
64