Smalltalk and Object Orientation: an Introduction - Free

is a controversial subject which is still being debated. Those who think it is useful fail to see why
other languages don’t include it and vice versa. Java the most recent object oriented language
does not include multiple inheritance.
1.9 Abstraction
We have already touched on the subject of abstraction in the previous section. However, abstraction is
much more than just the ability to define categories of things which can hold common features of other
categories of th ings (e.g. Student is an abstract class of Undergraduate-Student and
Postgraduate-Student). It is in fact a way of specifying what is particular about a class of
things. Often this means defining the interface for an object, the data that such an object wi ll hold and
part of the functionality of that object.
For example, we might define a class DataBuffer. This class may be used to define an abstract
class for things that hold data and return them on request. This class may define how the data is to be
held and that operators such as put() and get() will be provided to add data to the DataBuffer
and remove it from the DataBuffer respectively. In turn the implementation of these operators may
be left to those implementing another class which is a subclass of DataBuffer.
The class DataBuffer might, for example, be used to implement a Stack or a Queue. Stack
could implement get() as return the most recent data item added while Queue could implement it as
return the oldest data item held. In either case, a user of either class will know that put() and get()
are available and will work in an appropriate manner.
In some languages it can also be related to protection. For example, both C++ and Java have the
ability to state whether subclasses are allowed to overwrite data or procedures (and indeed whether they
have to overwrite them or not). Smalltalk does not provide the ability to state that a procedure cannot be
overwritten, but it does allow the developer to state that a procedure (or method) is a su bclass
responsibility. That is, a subclass is expected to implement the procedure in order to provide a
functioning class.
Abstraction is also associated with the ability to define Abstract Data Types (or ADTs). In object
oriented terms these are classes (or groups of classes) which provide some sort of behavior (e.g.
DataBuffer above) which acts as the infrastructure for a particular class of data types (e.g. things like
stacks and queues). However, it is worth pointing ou t that ADTs are more commonly associated with
procedural languages such as Ada. This is because the concepts in object orientation essentially
supersede ADTs. That is, not only do they encompass all the elements of ADTs, they extend them by
introducing inheritance.
1.10 Polymorphism
Polymorphism is a strange sounding (Greek derived) word for a relatively simple concept. It is
essentially the ability to request that the same operation be performed by a wide range of different types
of things. How that request is processed will depend on what it is that received the request. However,
you as a programmer, need not worry about how the request is handled, only that it is. For example, you
might ask a range of objects to provide a printable string describing themselves. This would mean that if
you wished to ask an instance of the Lecturer class (presented above or the system) or a compiler
object or a database object to return such a string, you would apparently use the same interface call
(such as printString in Smalltalk).
The name Polymorphism is unfortunate and often leads to confusion. Of course, it also makes the
whole process sound rather grander than it actually is. There are two types of polymorphism used in
programming languages: overloadi ng and overriding. The difference in name relates to how the
mechanism used to resolve what code to execute is determined. The difference between the two is
significant and is important to understand. To understand what polymorphism actually is, it helps t o
understand how these two different mechanisms work.
22