• 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

javaexamples/oopbasics/im2/Chirp.java

import java.util.*;

/**
 * A missive in an instant messaging system
 *
 * @author  Prof. David Bernstein
 * @version 2.0
 */
public class Chirp
{
    protected String          delimiters;  // Delimiters between words
    protected String          text;        // The text of the message

    /**
     * Explicit Value Constructor
     *
     * @param typed   What was typed by the user
     */
    public Chirp(String typed)
    {
        text       = typed;
        delimiters = " ,.;!?-\n\r";
    }

    /**
     * Get the number of words in this Chirp
     *
     * @return   The number of words
     */
    public int getNumberOfWords()
    {
        int                 numberOfWords;
        StringTokenizer     tokenizer;

        tokenizer     = new StringTokenizer(text, delimiters);
        numberOfWords = tokenizer.countTokens();

        return numberOfWords;
    }

    /**
     * Get the text of this Chirp
     *
     * @return   The text
     */
    protected String getText()
    {
        return text;
    }
}
        

javaexamples/oopbasics/im2/ExpandedChirp.java

import java.io.*;
import java.util.*;

/**
 * A missive in an instant messaging system
 *
 * Unlike a normal Chirp, an ExpandedChirp does not
 * contain abbreviations -- they are all expanded
 *
 * @author  Prof. David Bernstein
 * @version 2.0
 */
public class ExpandedChirp extends Chirp
{
    private Properties      abbreviations;


    /**
     * Explicit Value Constructor
     *
     * @param typed   What was typed by the user
     */
    public ExpandedChirp(String typed)
    {
        super(typed);
        InputStream      is;

        abbreviations = new Properties();
        try 
        {
            is = new FileInputStream("abbreviations.txt");
            abbreviations.load(is);
        } 
        catch (IOException ioe)
        {
            // There was a problem opening the file
            // containing the abbreviations
        }
    }

    /**
     * Get the text of this Chirp with all of the
     * abbreviations expanded
     *
     * @return   The text
     */
    public String getText()
    {
        String       tempText;

        // Use the protected attribute in the parent
        tempText  = replaceAbbreviations(text);

        return tempText;
    }

    /**
     * Replace the abbreviations in a message
     *
     * @param msg   The original message
     */
    private String replaceAbbreviations(String msg)
    {
        String              replaced, token, word;
        StringTokenizer     tokenizer;

        replaced = "";
        
        // Use the protected attribute in the parent
        tokenizer = new StringTokenizer(msg, delimiters, true);
        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();
            word  = abbreviations.getProperty(token);

            if (word == null) replaced += token;
            else              replaced += word;
        }

        return replaced;
    }
}
        

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

javaexamples/oopbasics/im2/ChirpRecorder.java

/**
 * A missive recorder in an instant messaging system.
 * In this version, there is a limit on the total number
 * of Chirp objects that can be recorded and all output is
 * sent to the console.
 *
 * @author  Prof. David Bernstein
 * @version 2.0
 */
public class ChirpRecorder
{
    private int            currentNumber;
    private Chirp[]        chirps;

    /**
     * Explicit Value Constructor
     *
     * @param size   The maximum number of Chirp objects to be recorded
     */
    public ChirpRecorder(int size)
    {
        chirps        = new Chirp[size];
        currentNumber = 0;
    }

    /**
     * Add a Chirp to this ChirpRecorder (if it is not
     * already full)
     *
     * @param msg   The Chirp to record
     */
    public void addChirp(Chirp msg)
    {
        if (currentNumber < chirps.length) {

            chirps[currentNumber] = msg;
            currentNumber++;
        }
    }

    /**
     * Show (on System.out) a previously recorded Chirp
     *
     * @param number   The number of the Chirp to show
     */
    public void showChirp(int number)
    {
        String     text;

        if (number < currentNumber) 
        {
            text = chirps[number].getText();
            System.out.println(text);
        } 
        else
        {
            System.out.println("No such chirp!");
        }
    }
}
        

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

javaexamples/oopbasics/im2/Driver.java

/**
 * A driver for an instant messaging system.
 *
 * @author  Prof. David Bernstein
 * @version 2.0
 */
public class Driver
{
    /**
     * The entry point of the application
     *
     * @param args   The command line arguments
     */
    public static void main(String[] args)
    {
        ExpandedChirp  english;
        Chirp          message;
        ChirpRecorder  recorder;


        recorder = new ChirpRecorder(10);

        message = new Chirp("FWIW I think he's arrogant. G2G");
        recorder.addChirp(message);

        english = new ExpandedChirp("SLAP.  TTYL");
        recorder.addChirp(english);

        System.out.println("\n\n");
        System.out.println("Showing 0 (a Chirp):\n");
        recorder.showChirp(0);
        


        System.out.println("\n\n");
        System.out.println("\nShowing 1 (an ExpandedChirp):\n");
        recorder.showChirp(1);
        
    }
}
        

• 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.

javaexamples/oopbasics/banking/Account.java

/**
 * A simple "bank" Account
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class Account
{
    protected double balance;
    protected int    id;

    /**
     * Default constructor
     */
    public Account() 
    {

        balance = 0;
        id = -1;
    }

    /**
     * Explicit Value Constructor
     *
     * @param idNumber        The ID for the Account
     * @param initialDeposit  The initial deposit
     */
    public Account(int idNumber, double initialDeposit)
    {
        balance = 0;

        id = idNumber;
        if (initialDeposit > 0) balance = initialDeposit;
    }

    /**
     * Determine the maximum amount that can be withdrawn
     *
     * @return The size of the maximum possible withdrawal
     */
    public double amountAvailable()
    {
        return balance;
    }

    /**
     * Deposit money in this Account
     *
   * @param amount    The size of the deposit
   *
   * @return false if unable to deposit and true otherwise
   */
    public boolean deposit(double amount)
    {
        boolean ok;

        ok = false;
        if (amount >= 0) {

            balance += amount;
            ok = true;
        }

        return ok;
    }

    /**
     * Obtain the ID of this Account
     *
     * @return The ID of this Account
     */
    public int getID()
    {
        return id;
    }
  
    /**
     * Withdraw money from this Account
     *
     * @param amount   The size of the withdrawal
     *
     * @return false if unable to withdraw and true otherwise
     */
    public boolean withdraw(double amount)
    {
        boolean     ok;

        ok = false;
        if (amount >= 0) {

            // Check if available funds are sufficient
            // 
            // Note: amountAvailble() is overriden in the 
            // derived class OverdraftAccount.
            // Which version of amountAvailable() will be 
            // called?
            //
            if (amountAvailable() >= amount) {

                balance -= amount;
                ok = true;
            }
        }

        return ok;
    }
}
        

javaexamples/oopbasics/banking/OverdraftAccount.java

/**
 * A "bank" Account that allows the owner to withdraw more money
 * than is in the account 
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class OverdraftAccount extends Account
{
    protected double   overdraftLimit;

    /**
     * Constructor
     *
     * @param idNumber        The ID for the Account
     * @param initialDeposit  The initial deposit
     * @param limit           The overdraft limit
     */
    public OverdraftAccount(int idNumber, 
                            double initialDeposit, double limit) 
    {
        balance = 0.0;
        
        id = idNumber;
        if (initialDeposit > 0) balance = initialDeposit;
        
        overdraftLimit = 0.0;
        if (limit > 0.0) overdraftLimit = limit;
    }

    /**
     * Determine the maximum amount that can be withdrawn
     *
     * Note: This method overrides amountAvailable() in Account.
     * This method is called by the method withdraw() which
     * is defined in Account.
     *
     * @return The size of the maximum possible withdrawal
     */
    public double amountAvailable() {

        return (balance+overdraftLimit);
    }
}
        

javaexamples/oopbasics/banking/Driver.java

/**
 * An example that uses an OverdraftAccount object
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class Driver
{
    /**
     * The entry point of the application
     *
     * @param args   The command line arguments
     */
    public static void main(String[] args)
    {
        double            amount;
        boolean           ok;
        OverdraftAccount  billSmith;


        billSmith = new OverdraftAccount(1001, 10000.00,5000.00);
        
        System.out.println("Account "+billSmith.getID()+
                           ": Opened with "+
                           "maximum withdrawl of "+
                           billSmith.amountAvailable());
        
        
        amount = 5000.00;
        ok = billSmith.deposit(amount);
        if (ok)
        {
            System.out.println("Account "+billSmith.getID()+
                               ": Deposit of "+
                               amount);
        } 
        else
        {
            
            System.out.println("Account "+billSmith.getID()+
                               ": Unable to "+
                               "make deposit of "+amount);
        }
        

        amount = 19000.00;
        ok = billSmith.withdraw(amount);
        if (ok)
        {
            System.out.println("Account "+billSmith.getID()+
                               ": Withdrawal of "+amount);
        } 
        else
        {
            System.out.println("Account "+billSmith.getID()+
                               ": Unable to "+
                               "make withdrawal of "+amount);
        }
    }
}
        

• 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