Objects are particularly well-suited to programs that involve modeling real or imaginary worlds such as graphical user interfaces (modeling windows, files, and folders on a desktop), simulations (modeling physical objects in the real world and their interactions), and games (modeling creatures and things in an imagined world).
Objects in the real world (or most simulated worlds) are complex. Suppose we are implementing a game that simulates a typical university. It might include many different kinds of objects including places (which are stationary and may contain other objects), things, and people. There are many different kinds of people, such as students and professors. All objects in our game have a name and a location; some objects also have methods for talking and moving. We could define classes independently for all of the object types, but this would involve a lot of duplicate effort. It would also make it hard to add a new behavior to all of the objects in the game without modifying many different procedures.
The solution is to define more specialized kinds of objects using the definitions of other objects. For example, a
student is a kind of
student has all the behaviors of a normal
person, as well as some behaviors particular to a
student such as choosing a major and graduating. To implement a
student class, we want to reuse methods from the
person class without needing to duplicate them in the
student implementation. We call the more specialized class (in this case the
student class) the subclass and say
student is a subclass of
person. The reused class is known as the superclass, so
person is the superclass of
student. A class can have many subclasses but only one superclass.1
Figure 10.2 illustrates some inheritance relationships for a university simulator. The arrows point from subclasses to their superclass. A class may be both a subclass to another class, and a superclass to a different class. For example,
person is a subclass of
movable-object, but a superclass of
Our goal is to be able to reuse superclass methods in subclasses. When a method is invoked in a subclass, if the subclass does not provide a definition of the method, then the definition of the method in the superclass is used. This can continue up the superclass chain. For instance,
student is a subclass of
person, which is a subclass of
movable-object, which is a subclass of
sim-object (simulation object), which is the superclass of all classes in the simulator.
Hence, if the
sim-object class defines a
get-name method, when the
get-name method is invoked on a
student object, the implementation of
get-name in the
sim-object class will be used (as long as neither
movable-object defines its own
When one class implementation uses the methods from another class we say the subclass inherits from the superclass. Inheritance is a powerful way to obtain many different objects with a small amount of code.
Some object systems (such as the one provided by the C++ programming language) allow a class to have more than one superclass. This can be confusing, though. If a class has two superclasses and both define methods with the same name, it may be ambiguous which of the methods is used when it is invoked on an object of the subclass. In our object system, a class may have only one superclass. ↩