Polymorphism by Brown University Computer Science Department 67

Transcription

1 5 Polymorphism Polymorphism, the ability of subclasses to respond differently to the same messages, is perhaps the most important part of object-oriented programming. Polymorphism models something quite important about the real world, namely that different things behave differently, even when abstractly engaging in the same activity. As an example, ask any number of people to do some task, chances are no two of them will do it in the exact same way! Inheritance allows us to take advantage of polymorphism because different subclasses can respond to the same message in different ways. In fact, an abstract method states that subclasses must exploit polymorphism because they have to define all the abstract methods. From a modeling perspective, an abstract method says that certain kinds of objects must be able to respond to certain kinds of messages, but it says nothing about how the objects will respond. As we said in the last chapter, the superclass sets a policy to be implemented by its subclasses. For example, Chapter 4 discussed different types of Animals. A Lion eats by killing Gazelles, but a Cow would eat by grazing. However, since a Cow and a Lion are Animals, we know that they both have the ability to eat. Polymorphism takes advantage of the fact that different subclasses of the same superclasses have the same capabilities (i.e., provide the same methods), even though the subclasses implement their methods differently. Another way to exploit polymorphism in our models is by noting that any instance of a subclass is also effectively an instance of its superclass. For example, an instance of the Lion class is also an instance of the Mammal class and of the Animal class. An instance of a subclass has at least all of the properties and can respond to all the same messages as an instance of a superclass. Thus, any place we expect an instance of a particular class, we can also use an instance of a subclass. A variable of the superclass type can represent many (poly) forms (morph) because it can have instances of its own type and those of its subclasses as its value this is where the term polymorphism comes from. We will use polymorphism extensively throughout CS15. All this probably sounds pretty abstract to you; the mechanics below will make it easier. 67

2 68 Chapter 5 Polymorphism MECHANICS In Chapter 4, we defined two specific types of Animal: a Herbivore and a Carnivore. We then got even more specific and defined a concrete subclass of Carnivore a Lion class which eats Gazelles. In this chapter, we will start by figuring out how to make our Lion eat all types of prey. We will also define a class to represent a meal in the jungle. Finally, we will show how each method is actually invoked in response to the messages sent when the animals eat their meal. Our old Lion class had a _prey instance variable of type Gazelle. This means that the Lion could only eat Gazelles. If we re modeling the jungle, we can t assume that there are always Gazelles to be found. So instead, let s start our Lion off with a FieldMouse as its prey, since there are plenty of those around. 1 public class Lion extends Carnivore { private Animal _prey; //can hold an instance of any subclass public Lion(){ super(); _prey = new FieldMouse(); // something in abundant supply _prey.die(); public void killprey(){ _prey = new Gazelle(); _prey.die(); public Leftovers eatprey(){ return _prey.asleftovers(); The constructor is basically the same as last time, except we initialized _prey to be an instance of FieldMouse instead of a Gazelle. In fact, we see that _prey appears twice on the left side of the assignment operator within this Lion code, once getting an instance of a FieldMouse and once getting an instance of a Gazelle. This is exactly what we mean by polymorphism one instance variable can hold different types of instances at different times, as long as they are subclasses of the same superclass that is the type of the instance variable. Since we declared it to be of type Animal, we can only send it messages to which an Animal would be able to respond. However, it 1. What would be really nice is to have killprey take a parameter, the prey. But since the only method that uses killprey is the eat method in Animal, that abstract method would have to take a parameter. Deciding the polymorphic type for that parameter so that both Carnivore and Herbivore can eat in an appropriate fashion complicates the example considerably, and hence we don t show that.

3 Mechanics 69 really will hold instances of subclasses, which will respond to each message as defined in the subclass. Because Animal is abstract (as we mentioned last chapter), it cannot be instantiated and therefore cannot directly be a value for _prey. Now let s look at the eatprey method, which returns the _prey, converted into Leftovers by using a method called asleftovers. In order for this to be possible, we must modify the Animal superclass to support the method asleftovers, and then redefine it in subclasses to return an appropriate subclass of Leftovers. In fact, this sort of refinement is common when programming; we did not think about how we would get leftovers when we were creating the first pass of the Animal class. Now that we have filled in more detail in our model, we can see that all animals may be prey to another species. Since the asleftovers method will be abstract (what are the leftovers of a generic animal?), we will leave it as an exercise to add its declaration to the Animal superclass and its definition to the Lion class. However, let s look at a definition for the Gazelle class to see how the details work: public class Gazelle extends Herbivore { public Gazelle(){ super(); public Leftovers eatplants(){ return new GrassLeftovers(); //GrassLeftovers is subclass //of Leftovers public Leftovers asleftovers(){ return new GazelleLeftovers(); //GazelleLeftovers is //subclass of Leftovers The asleftovers method is used when a carnivore eats this gazelle. In the carnivore s eatprey method, it needs to call the asleftovers method of its prey. This way the prey changes from being represented as an Animal to being represented as Leftovers and can be used for methods which require Leftovers (such as the simulatemeal method we will see in a few pages) This is another example of polymorphism being used to simplify our method because the Animal class does not care what actual Leftovers are being produced, so long as they act like Leftovers. In fact, it would be close to impossible to redefine methods in a subclass without polymorphism because the method declarations in both classes must match. It is a compiletime error to define a method in a subclass that is exactly like the declaration in the superclass, but returns a different type of object in the body of the method. In this case, all the asleftovers method does is return a new object that represents a Gazelle as Leftovers. In fact, this is a naming convention we

4 70 Chapter 5 Polymorphism will use throughout these chapters. If you ever need to change an object s representation (i.e., from a Gazelle into GazelleLeftovers), the name of the method that performs this change should be asotherclass. Partial Overriding What if a superclass does some useful work in its method that a subclass does not want to replace, but instead wants to augment? In this case, the subclass must define its own method and, within this method, send a message directly to its superclass, telling it to do its work. This gives the subclass complete control over how it uses its superclass implementation. To call a superclass method from a subclass methods, we must use the Java keyword super. In this case, super works as it did in the Inheritance chapter within the constructor, except that we are now using it to call methods defined in our superclass, instead of sending a message to the current instance (which as you might remember we specified by using this). Let s look at this in code: public class CleanLion extends Lion { private LionBib _bib; public CleanLion(){ super(); _bib = new LionBib(); public Leftovers eatprey() { Leftovers waste; _bib.puton(); waste = super.eatprey(); _bib.remove(); return waste; In this example, a CleanLion eats basically the same way that a Lion does, it just wants to take some precautions first to make sure it stays clean. To do this, it puts on a bib before eating the gazelle and takes it off after it is done. In code, it does this by defining its own eatprey method (redefining the Lion s): it does its own extra work (putting on the _bib), and then forwards the message on to its superclass (eatprey the way other Lions do), and finally finishes the meal (by taking off its _bib). This technique is an effective way to avoid repeating the superclass code in each subclass (like we did in our EvilLion example last chapter). Notice that we used a local variable to hold on to the Leftovers while the CleanLion takes off its bib. Then we simply returned the Leftovers to the calling method. Although the method does not modify the Leftovers in

5 Mechanics 71 any way before returning them to the calling method, it needed to hold on to them while it completed the task of eating. Had it simply returned after calling the superclass eatprey method, it would have had no chance to take off the bib (and the other Lions might have laughed). Determining Which Method is Invoked With a complex set of classes and superclasses, it can sometimes be confusing trying to figure out how a particular instance will respond to a message. You can always figure it out, though, by looking first at the class of the instance. You should not look at the superclass, but at the actual class from which the instance was instantiated the class name after the new in an initialization statement. If you find a method with the right name there, that s the method the instance will use. If not, look next in the superclass of this class. If the superclass doesn t have a method by the right name, look in the superclass superclass, and so on, until the class definitions no longer list a superclass using extends. At that point, there is one final place to look for a suitable method. Any class that does not explicitly extend another class extends the special class Object. Where does the class Object come from? Object is a special class that all classes in Java inherently extend from even though it will never be explicitly declared. (Remember how the compiler automatically puts in a super() if you didn t call the superclass constructor yourself? This is why it works every Java class extends Object.) So before you give up trying to find out which method will be called, you can look in the class definition for Object to see if there is a method with the right name. 2 If there is, fine that method is used. If there isn t, a compile-time error has occurred because the message was not understood. Java will tell you this, and it will be up to you to figure out why the message was not understood. Perhaps the message name was simply misspelled. Perhaps the message was sent to the wrong object. In any case, your error needs to be fixed. This process of determining which method to use is called method resolution. Let s examine this process of method resolution in more detail with a more complicated example. Suppose we want to simulate our animals having a jungle meal. A jungle meal typically consists of eating one s food and leaving the leftovers as waste to pile up on the jungle floor. At that point, it may be further consumed by scavenger animals, but we will not model that possibility here. To illustrate our point, we will make a JungleMeal class that contains a number of animal instance variables. This class will construct some number of concrete subclasses to actually simulate their behavior. We will then trace how Java finds the right method to use. This type of hand simulation is 2. It is unlikely in this introductory course that you will be using any methods found in Object.

6 72 Chapter 5 Polymorphism tricky you must do it carefully and methodically to make sure code does what you want it to do. Indeed, writing polymorphic code takes practice. public class JungleMeal { private Herbivore _herb; private Carnivore _carni; private Animal _bob; private Leftovers _waste; public JungleMeal(){ _herb = new Gazelle(); _carni = new Lion(); _bob = new CleanLion(); _waste = new FieldMouse().asLeftovers(); public void simulatemeal() { _waste = _herb.eat(); this.accumulateleftovers(); _waste = _carni.eat(); this.accumulateleftovers(); _waste = _bob.eat(); this.accumulateleftovers(); _herb.sleep(); _carni.sleep(); _bob.sleep(); public void accumulateleftovers(){ _waste.pileuponjunglefloor(); In order to determine which instance s method is used, we must keep close track of each variable s actual class type. Let s look at the JungleMeal class instance variable declarations in a little more detail: Herbivore _herb; Carnivore _carni; Animal _bob; At this point, it is important to distinguish between a variable s declared type and its actual type. The declared type is the class appearing in the declaration; it determines to which methods this instance will respond. The actual type is the one used after the keyword new on the right side of an equals sign (in this case in the constructor). _herb = new Gazelle(); _carni = new Lion(); _bob = new CleanLion();

7 Mechanics 73 The declared type of an object can be the same as the actual type, or anything more general than the actual type like a superclass. Thus, even though the JungleMeal class only declares classes of type Herbivore, Carnivore, and Animal, objects of type Gazelle, Lion, and CleanLion are actually instantiated. This type of polymorphism is a powerful feature of inheritance: it lets us treat a very specific class, a CleanLion, as a more general class, an Animal. Later, we could add a new type of animal, say an elephant, and, without changing the simulatemeal method of the JungleMeal class, initialize _bob with a reference to our new Elephant class and use the its eat method. This allows your simulatemeal code to be used without modification, even with objects you did not initially plan on. In a minor way, though this limits our flexibility. If CleanLion has a method called cleanfur which is not declared in Animal, we cannot use the _bob instance variable to call _bob.cleanfur(). This is because the declaration of _bob only says that it is an Animal. We can only tell _bob to do whatever an Animal knows how to do. This is usually offset by the great advantages of polymorphism discussed above. Given these instance variable definitions, let s take a closer look at the simulatemeal method of the JungleMeal class. Before looking at the actual code, we will describe the method s high-level intent. This method simulates three jungle animals eating a typical jungle meal. Which three animals is unimportant to the actual process of the simulation any three will do (in this case, the class is initialized with a Gazelle, alion, and a Clean- Lion). In this simulation, each animal eats to its fill, leaving some waste behind to accumulate on the jungle floor. Given this purpose, let s examine the first line of code in the simulatemeal method: _waste = _herb.eat(); Although the declared type of this object is a Herbivore, the instance is actually a Gazelle. The instance is shown in Figure 5.1, along with the hierarchy of subclasses of the Animal class. Note that this figure shows where each method was defined, not necessarily which messages each class in the hierarchy supports. Using the process of method resolution described at the beginning of the section, the first definition of eat that Java finds is in the Herbivore class. At this point, Java attempts to execute the statements within the Eat method. The first message it encounters is the eatplants message. Remember that this message is being sent to the current object, so Java must determine its actual type in order to determine which method to use to respond to the message sent. The actual type of the current object is still Gazelle, even though it is responding to eat as a Herbivore would. Thus, Java starts looking for a method with which to respond to the eatplants message with the Gazelle class and there it finds a definition. The Gazelle s eatplants method just returns a new instance of GrassLeftovers. And that instance is returned by the Herbivore s eat

8 74 Chapter 5 Polymorphism Figure 5.1 An instance of a Gazelle used as a Herbivore. sleep die Animal Herbivore eat _herb = new Gazelle(); (Gazelle) (instance of) Gazelle eatplants asleftovers method. Finally, this instance is assigned to the instance s variable _waste in the instance of the JungleMeal class. That completes this single Java statement! The next statement is much simpler: the accumulateleftovers message is sent to the JungleMeal instance which just tells the waste to pile up on the jungle floor. A Java program is dynamic, meaning that the values of properties and the state of objects can change during run-time. This means that a variable can be assigned to an object of one type and act as that type, but can then be assigned to an object of another type, and it will act as this new object. Thus, method calls are dynamically bound: meaning that the actual method called depends on what type of object is currently assigned to the variable receiving the message. This idea is what gives polymorphism its power. The next two lines are very similar to the ones we just described so we will not describe them in detail here. An important thing to notice is that we are replacing the value of the _waste instance variable after the Carnivore eats. In effect, this wipes out the JungleMeal s knowledge of the Herbivore s waste and replaces it with the Carnivore s waste. In this case, this is just fine because we have already told the Herbivore s waste to pile up on the jungle floor. Let s hand simulate the next line of code: _waste = _bob.eat(); Looking at Figure 5.2, we see an instance of a CleanLion being used in the JungleMeal class as an Animal. Which definition of eat is used? Java determines the reference is a CleanLion, so it looks for a definition of eat within that class. When it cannot find one there it continues up the inheritance hier-

9 Mechanics 75 archy, to the more general classes, until it finds a definition in the Carnivore class. Figure 5.2 A instance of a CleanLion used as an Animal sleep die Animal Carnivore bob = new CleanLion(); eat Lion Animal _prey killprey eatprey asleftovers (CleanLion) (instance of) CleanLion LionBib _bib eatprey The first line of the Carnivore s eat method is to send a message to the current object telling it to killprey. Here it finds a definition in the Lion class. It completes executing that method, returns to the calling method, the Carnivore s definition of eat, and attempts to eat the prey. Since the actual instance is a CleanLion, Java uses the lowest level definition of eatprey, the one in the CleanLion class not the one in the Lion class. Within the CleanLion s response to eatprey, after putting the bib on, we find another message send to eatprey. However, since this one is prefaced by the Java keyword super, it tells Java to look for a method of response to the eatprey message within superclasses of the current class. This means it begins looking for a method definition within the Lion class and continues looking in classes higher up the hierarchy if it didn t find one there. In this case, however, it does find one in the Lion class, so it stops looking and executes that method. When it is done, it returns to the CleanLion s eatprey method and takes off the bib. Finally the leftovers are returned and stored in the JungleMeal instance s _waste variable (replacing the current value).

10 76 Chapter 5 Polymorphism So, now what about the sleep messages? In this case, none of the subclasses replace the definition of the Animal s Sleep method. So no matter what the actual type of the instance is, the Animal class definition is used. If one of the subclasses were to replace the definition, Java would find it in the same way it did the eat message. Polymorphism Can Be Tricky Let s say that class Zoo has the following method: public void feedlion(lion tofeed) {... and we construct a local variable with declared type Animal and actual type Lion: Animal myanimal = new Lion(); Can we pass our myanimal variable into the feedlion method? The answer is no. An important statement to remember about Parameters and Polymorphism is: Declared type of actual parameter must be same class (or subclass) of declared type of formal parameter. In the above example, Animal (declared type of actual parameter) is the superclass of Lion (declared type of formal parameter). Because of this, we are not allowed to pass myanimal into the feedlion method. REVIEW OF INHERITANCE PRINCIPLES Creating and understanding a fully functional class hierarchy involves understanding three main concepts: completely defining, completely redefining, and extending. Understanding these three terms is the key to understanding how inheritance works, what is required, and how to determine which method is invoked. A method is defined if there are curly braces after its signature (even if there is no code between the braces that is just an empty method). Completely defining all methods in a class means that no methods are abstract and no inherited methods are left abstract. Once all methods in a class are completely defined, that class may be instantiated. When a method is invoked on a class, Java will begin method resolution at that class and move up the inheritance tree until it finds a completely defined method. It will then execute the code in that method.

11 Summary 77 Completely redefining a method means that that method has been overridden. Redefining a method ignores what was written in the superclass under the same signature and tells Java to use the new code instead. Since the new definition is lower on the inheritance tree, Java will see that definition first and know to use it instead of the superclass whenever that method is invoked on that subclass. Extending a class means adding capabilities to an existing class by making a subclass of it. The class that is extending inherits all public capabilities of the superclass and then adds its own features. This may involve defining existing abstract methods, redefining or partially overriding existing nonabstract methods, declaring new abstract methods, and/or declaring and defining new non-abstract methods. Extending a class gives you the opportunity to change a class and affect what methods are invoked along the inheritance tree. You can override a method so that any code written for that method in the superclasses is ignored. You can also partially override a method so that code in your new subclass is executed along with the code from that method in the superclass(es). Using the reserved word, super, partial overriding allows you to tell Java to continue walking up the inheritance tree. If you understand these three concepts and how they inter-relate, you should be able to go through a thorough hand-simulation of the sequence of method interactions that travel through an inheritance tree, and therefore, understand in detail how your code will work. SUMMARY Polymorphism lets us program with great generality, making methods generic, for example, by using superclass types as the declared types of formal parameters, while letting callers pass in actual types of subclasses for the actual parameters. (Note that the adjective actual is used here in different ways the actual type of the actual parameters ) We will extend our notion of polymorphism for even greater generality by allowing interfaces, covered in the next chapter, to be the declared type of formal parameters, as well as of variables.

12 78 Chapter 5 Polymorphism