In chapter 
it is summarized how to define classes and
instances of classes. It is shown how
methods in classes can be activated
via message passing. More interesting for all but novices
in the field, it is also worked
out how to use generic procedure calls instead of
message passing.
Chapter introduces hierarchies of classes and
inheritance of methods. Two particular state variables
are introduced, namely self
and super
.
It is discussed how self
can be defined in case
we want to simulate virtual-like procedures (in the Simula sense).
Two different representations
of objects are discussed in this chapter.
The most elaborate of these is called the object precedence
list representation, and it is really introduced as a preparation
for the chapter on multiple inheritance.
Multiple inheritance is the theme of chapter .
Two different approaches to the handling of multiple inheritance
are discussed. The first of these can be characterized as
a natural ``first try''. The other one deals with
how to avoid multiple instantiations of parts of objects.
In addition I discuss in this chapter how a method
combination facility can be simulated. The chapter is
concluded with a section on a simple method caching technique,
which speeds up the method lookup process.
In chapter it is discussed how classes themselves
can be treated as objects. The underlying classes of class-objects
are traditionally called metaclasses,
and the objects which represent the classes are called meta-objects.
I describe an exercise in the definition of the most general classes
in a class hierarchy and a metaclass hierarchy.
The purpose of this exercise is to demonstrate how experience
in this enterprise can be collected via simulations
in Scheme.
As an important part of the exercise I focus on how
object instantiation can be arranged via message passing to
the meta-objects.
Besides a bibliography, there is an program index at the end of the report.