Polymorphism

• Polymorphism ("many forms") means:
  • the ability to produce different behaviour with a superclass method, depending on the subclass we are actually referencing
• What does this actually mean?

Polymorphism: an example scenario

• Imagine we have an object of the superclass type which actually points to an instance of the subclass, and when we call a method, the subclass version of the method will be called
• One example would be where we group together different subclasses in an array of objects of the superclass
  • e.g. an array of Shapes containing a mixture of Rectangles, Triangles and Circles
• Calling a method on each member of the array in turn will cause the subclass behaviour to be exhibited

Polymorphism Example

• Shape drawing:

  Shape[] shapes = new Shape[3];
  shapes[0] = new Rectangle (4, 3, Color.green); 
  shapes[1] = new Circle (4, Color.blue); 
  shapes[2] = new Square (5, Color.red); 
  
  for(int count=0; count<3; count++)
  {
      shapes[count].draw();
  }
  

• Even though the array and its members are of type Shape, when we loop through the shapes, the subclass draw() method will be called, giving us the correct shapes

Runtime Binding

• Polymorphism is able to occur due to runtime binding
• Runtime binding means:
  • the method to call is decided at run time (when the program is run) rather than when we compile the program
• Without runtime binding, polymorphism would not be possible
• The example below illustrates why

Example illustrating Why Runtime Binding Must Occur for Polymorphism to Work

Employee[] employees = new Employee[100];
Scanner scanner=new Scanner(System.in);
for(int count=0; count<100; count++)
{
    System.out.println("What sort of employee   (1=programmer; 2=manager)");
    String typeString = scanner.nextLine();
    int type=Integer.parseInt(typeString);
    if(type==1)
    {
        // ... read in job title and favourite programming language ...
        System.out.println("Programmer: enter job title");
        String jobTitle=scanner.nextLine();
        System.out.println("Enter favourite language:");
        String favouriteLanguage=scanner.nextLine();
        employees[count]=new Programmer(jobTitle,favouriteLanguage);
    }
    else if (type==2)
    {
        // ... read in job title and number of shares in the company ... 

        System.out.println("Manager: enter job title");
        String jobTitle=scanner.nextLine();
        System.out.println("Enter number of shares in company:");
        int shares=Integer.parseInt(scanner.nextLine());
        employees[count]=new Manager(jobTitle,shares);
    }
}

for(int count=0; count<100; count++)
{
    employees[count].printDetails();
}

• This example reads in a series of Employees (Programmers or Managers) from the keyboard and stores them in an array
• The exact type of each Employee in the array is not known until the user has chosen the employee type, which happens at run time
• The compiler cannot possibly know which method to call as the compiler cannot tell in advance which type of Employee the user is going to enter (obviously!)

Polymorphism in Method Parameters

• Another scenario where polymorphism is freqently observed is in method parameters
• A method parameter of any given superclass will allow us to pass in any subclass of that superclass as an argument to the method
  • e.g. if the parameter is of type Object, we can pass in an instance of any class
  as an argument
• If we then perform an operation on the object passed to the method, the object will behave as the appropriate subclass, even though the type of the parameter is the superclass

Polymorphism in Method Parameters: Example

class Oven
{
    public void cook (Food f)
    {
        int n = f.getCookingTime();
        System.out.println("Cooking for " + n + "minutes.");
    }
}

• The Oven class includes a cook() method which takes an item of Food as a parameter and displays its cooking time
• This allows cook() to cook any subclass of Food
• The getCookingTime() method of the particular subclass of Food that has been added to the Oven will be called....
• even though f is of type Food
• So, the parameter f will exhibit different behaviour depending on what subclass it refers to
• This is polymorphism again:
  • different behaviour from the same method depending on the subclass

Oven example, continued

• Imagine the following:
  • The getCookingTime() method of Fish returns 50 * the weight of the fish
  • The getCookingTime() method of Vegetables returns 10 * the weight of the vegetables
  • The getCookingTime() method of Cake returns 100 * the weight of the cake
  • The constructor of each food type expects a weight

  • class Food
    {
        protected int weight;
        public Food(int w) { weight=w; }
        public int getCookingTime()
        {
            return 0;
        }
    }
    
    class Fish extends Food
    {
        public Fish(int w) { super(w); }
        public int getCookingTime()
        {
            return 50*weight;
        }
    }
    
    class Vegetables extends Food
    {
        public Vegetables(int w) { super(w); }
        public int getCookingTime()
        {
            return 10*weight;
        }
    }
    
    class Cake extends Food
    {
        public Cake(int w) { super(w); }
        public int getCookingTime()
        {
            return 100*weight;
        }
    }
    

• The following code:

  Oven oven = new Oven();
  Fish f = new Fish(3);
  Vegetables v = new Vegetables(4);
  Cake c = new Cake(2);
  oven.cook(f);
  oven.cook(v);
  oven.cook(c);
  

  will give us the following results:

  Cooking for 150 minutes.
  Cooking for 40 minutes.
  Cooking for 200 minutes.
  

  Even though the data type of the parameter passed to Oven.cook() is Food, it will be referring to a subclass, so the subclass version of getCookingTime() will be called