• Suppose we have the following:
  • public class Chirp {...}
  • public class ExpandedChirp extends Chirp {...}
  • public void addChirp(Chirp ch) {...}
• Will the compiler allow us to:
  • pass a Chirp object to the addChirp() method?
  • pass an ExpandedChirp object to the addChirp() method?

• What is the compiler concerned about in these cases?
  • Whether the right-side operand of the membership operator will be recognized for the parameter ch
• Obviously, this isn't a problem when we:
  • pass a Chirp object to the addChirp() method (since the formal parameter is declared to be a Chirp)
• It also isn't a problem when we:
  • pass an ExpandedChirp object to the addChirp() method (since the ExpandedChirp class inherits the accessible attributes from the Chirp class)

• Suppose we have the following:
  • public class Chirp {...}
  • public class ExpandedChirp extends Chirp {...}
• Will the following compile?
  • Chirp c; c = new Chirp("JMU");
  • Chirp c; c = new ExpandedChirp("JMU");
  • ExpandedChirp e; e = new ExpandedChirp("JMU");
  • ExpandedChirp e; e = new Chirp("JMU");

• Suppose in the previous example:
  • Chirp has a getText() method
  • ExpandedChirp overrides the getText() method
• What happens at run-time if:
  • addChirp() is passed a Chirp object and calls the getText() method?
  • addChirp() is passed an ExpandedChirp object and calls the getText() method?

• Etymology:
  • From the Greek - "having many forms"
• Some Uses of the Term:
  • Coercion of one type to another can be thought of as polymorphism
  • Method overloading can be thought of as polymorphism
• Our Concern Here:
  • Polymorphism that results from specialization (which is often called subclass polymorphism)
  • The related concept called dynamic binding

Since an ExpandedChirp "is a" Chirp, we know that a Chirp[] (i.e., an array of references to Chirp objects) can contain both.

What we need to know is what happens when an element's getText() method is called.

• An Observation:
  • It is not really clear what we mean when we say that the getText() method of the Chirp object is called
• An Alternative:
  • In OOP we often say that a getText() message is sent to the Chirp object
  • We can then talk about which particular method is executed when the message is received

• Class Membership
  • The compiler uses the declared class
  • At run-time an object knows its class (i.e., the class that it is a member of is determined by the constructor that was used to instantiate it)
• Search Order:
  • If the "message" is sent to an object of the derived class then the derived class is searched (for the existence of such a method) first and the base class is searched second. (Note: The search will move up the class hierarchy as needed.)
  • If the "message" is sent to an object of the base class then only the base class is searched.

• In the Current Chirp Class:
  • The getNumberOfWords() method uses the protected String attribute named text
• Suppose:
  • It used the getText() method instead
• What Happens at Run-Time When:
  • A getNumberOfWords() message is sent to a Chirp() object?
  • A getNumberOfWords() message is sent to an ExpandedChirp() object?

• Sending a Message to an Object (that is Polymorphic):
  • The Issue - Because the object is polymorphic, the method can be anywhere in the class tree
  • In Java - Dynamic binding (at run-time) is used to determine the code that is executed
• Passing an Object (that is Polymorphic) as a Parameter:
  • The Issue - Because the object is polymorphic and methods can be overloaded, there can be more than one method that could be invoked
  • In Java - Static binding is used (at compile-time) to determine which method to invoke

• Suppose we have the following classes:
  • public class Chirp {...}
  • public class ExpandedChirp extends Chirp {...}
• And the following methods in another class:
  • public void add(Chirp ch) {...}
  • public void add(ExpandedChirp ch) {...}
• What happens at run-time when:
  • add() is passed a Chirp that is declared to be a Chirp?
    
    add(Chirp ch) is executed -- there is no other option
    
  • add() is passed an ExpandedChirp that is declared to be an ExpandedChirp?
    
    add(ExpandedChirp ch) is executed -- this is not a situation in which dynamic/late binding is used at run-time, the declared type is used at compile-time to determine which method will be executed
    
  • add() is passed an ExpandedChirp that is declared to be a Chirp?
    
    add(Chirp ch) is executed -- again, the declared type is used at compile-time to determine which method is executed
    

• Suppose we have the following classes:
  • public class Chirp {...}
  • public class ExpandedChirp extends Chirp {...}
• And the following methods in another class:
  • public void add(Chirp ch) {...}
• What happens at compile-time and run-time when:
  • add() is passed an ExpandedChirp that is declared to be an ExpandedChirp?
    
    Compile-Time: The call to add() compiles because an ExpandedChirp is a Chirp
    
    
    Run-Time: add(Chirp ch) is executed -- there is no other option
    
  • add() is passed an ExpandedChirp that is declared to be a Chirp?
    
    Compile-Time: The call to add() compiles because the actual parameter is declared to be the same type as the formal parameter
    
    
    Run-Time: add(Chirp ch) is executed -- there is no other option
    

• Suppose we have the following classes:
  • public class Animal {...}
  • public class Mammal extends Animal {...}
  • public class Sheep extends Mammal {...}
• And the following methods in another class:
  • public void add(Animal item) {...}
  • public void add(Mammal item) {...}
• What happens at run-time when:
  • add() is passed an Animal that is declared to be an Animal?
    
    add(Animal item) is executed -- there is no other option
    
  • add() is passed a Mammal that is declared to be a Mammal?
    
    add(Mammal item) is executed -- the declared type is used
    
  • add() is passed a Sheep that is declared to be a Sheep?
    
    add(Mammal item) is executed -- there is no method matching the declared type but a Sheep "is a" Mammal and a Sheep "is a" Animal so both methods could be executed; the most specific/specialized version is executed