inheritance
- 1. 10.2 Inheritance 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 person.
- 2. A student has all the behaviors of a normal person, as well as some behaviors particular to a studentsuch 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 thestudent implementation. We call the more specialized class (in this case thestudent 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 student andprofessor. Figure 10.2: Inheritance hierarchy.
- 3. 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-namemethod is invoked on a student object, the implementation of get-name in thesim-object class will be used (as long as neither person nor movable-objectdefines its own get-name method). 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.
- 4. 10.2.1 Implementing Subclasses To implement inheritance we change class definitions so that if a requested method is not defined by the subclass, the method defined by its superclass will be used. The make-sub-object procedure does this. It takes two inputs, a superclass object and the object dispatching procedure of the subclass, and produces an instance of the subclass which is a procedure that takes a message as input and outputs the method corresponding to that message. If the method is defined by the subclass, the result will be the subclass method. If the method is not defined by the subclass, it will be the superclass method. (define (make-sub-object (lambda (message) super subproc) (let ((method (subproc (if method method (super message))))) message))) When an object produced by (make-sub-object obj proc) is applied to a message, it first applies the subclass dispatch procedure to the message to find an appropriate method if one is defined. If no method is defined by the subclass implementation, it evaluates to (super message), the method associated with themessage in the superclass.
- 5. References to self. It is useful to add an extra parameter to all methods so the object on which the method was invoked is visible. Otherwise, the object will lose its special behaviors as it is moves up the superclasses. We call this the selfobject (in some languages it is called the this object instead). To support this, we modify the ask procedure to pass in the object parameter to the method: (define (ask object message . args) (apply (object message) object args)) All methods now take the self object as their first parameter, and may take additional parameters. So, the counter constructor is defined as: (define (make-counter) (let ((count 0)) (lambda (message) (cond ((eq? message 'get-count) (lambda (self) count)) ((eq? message 'reset!) (lambda (self) (set! count 0))) ((eq? message 'next!) (lambda (self) (set! count (+ 1 count)))) (else (error "Unrecognized message")))))) Subclassing counter. Since subclass objects cannot see the instance variables of their superclass objects directly, if we want to provide a versatile counter class we need to also provide a set-count! method for setting the value of the counter to an arbitrary value.
- 6. For reasons that will become clear later, we should useset-count! everywhere the value of the count variable is changed instead of setting it directly: (define (make-counter) (let ((count 0)) (lambda (message) (cond 'get-count) (lambda (self) count)) val) (set! count val))) ((eq? message 'set-count!) (lambda (self((eq? message (else (error "Unrecognized message")))))) Previously, we defined make-adjustable-counter by repeating all the code frommake- counter and adding an adjust! method. With inheritance, we can definemake-adjustable-counter as a counter without repeating any code: subclass of make- (define (make-adjustable-counter) (make-sub-object (make-counter) (lambda (message) (cond 'adjust!) val) 'get-count) val)))) ((eq? message (lambda (self (ask self 'set-count! (+ (ask self (else false))))) We use make-sub-object to create an object that inherits the behaviors from one class, and extends those behaviors by defining new methods in the subclass implementation. ((eq? message 'reset!) (lambda (self) (ask self 'set-count! 0))) ((eq? message 'next!) (lambda (self) (ask self 'set-count! (+ 1 (ask self 'current)))))
- 7. 10.2.2 Overriding methods In addition to adding new methods, subclasses can replace the definitions of methods defined in the superclass. When a subclass replaces a method defined by its superclass, then the subclass method the superclass method. When the method is invoked on a subclass object, the new method will be used. For example, we can define a subclass of reversible-counter that is not allowed to have negative counter values. If the counter would reach a negative number, instead of setting the counter to the new value, it produces an error message and maintains the counter at zero. We do this by overriding the set-count! method, replacing the superclass implementation of the method with a new implementation. (define (make-positive-counter) (make-subobject (make-reversible-counter) (lambda (message) (cond 'set-count!) ((eq? message (lambda (self val) (if (< val 0) (error "Negative count") ...))) (else false))))) What should go in place of the ……? When the value to set the count to is not negative, what should happen is the count is set as it would be by the superclassset-count! method. In the positive-counter code though, there is no way to access the count variable since it is in the superclass procedure's application environment.
- 8. There is also no way to invoke the superclass' set-count! method since it has been overridden by positive-counter. The solution is to provide a way for the subclass object to obtain its superclass object. We can do this by adding a get-super method to the object produced bymake-sub-object: (define (make-sub-object (lambda (message) super subproc) (if (eq? message 'get-super) (lambda (self) super) (let ((method (subproc (if method method (super message)))))) message))) Thus, when an object produced by make-sub-object is passed the get-supermessage it returns a method that produces the super object. The rest of the procedure is the same as before, so for every other message it behaves like the earlier make-sub-object procedure.