• In object oriented programming, polymorphism usually refers to the effect of dynamic dispatch.
  • S is a subclass of T.
  • S overrides a method f() defined in T.
  • Variable v of type T is assigned to an object of type S. → T v = new S();
  • v.f() uses the definition from S rather than T.
• To Summarize → Every object kind of “knows” what it needs to do.
• More generally → Polymorphism refers to behaviour that depends only on specific capabilities.
  • i.e. polymorphism allows different objects with distinct capabilities to be treated uniformly based on a shared set of features or behaviours.
  • The behaviour exhibited is not constrained by the exact nature of the object but determined by the capability it provides.
  • Example:
    • Reverse an array/list. (Should work for any type)
    • Search for an element in an array/list. (Work for any type that have the capability of equality check.)
    • Sort an array/list. (Works for type that can compare its values with others.)

Structural Polymorphism

To understand the above points → We simulate this using Java Class Hierarchy.

1. Polymorphic reverse

   public void reverse(Object[] objarr){
   	Object tempobj;
   	int len = objarr.length;
   
   	for(int i=0;i < n/2; i++){
   		tempobj = objarr[i];
   		objarr[i] = objarr[(n-1)-i];
   		objarr[(n-1)-i] = tempobj;
   	}
   }
   

2. Polymorphic find

   public int find(Object[] objarr, Object o){
   	int i;
   	for(i=0;i<objarr.length;i++){
   		if(objarr[i] == o) { return i; }
   	}
   	return (-1);
   }
   

   • == translates to Object.equals()

3. Polymorphic sort

   public interface Comparable{
   	public abstract int cmp(Comparable s);
   }
   .....
   public class SortFunctions{
   	public static void quicksort(Comparable[] a){
   		...
   		//Use the code for quicksort.
   		//In place of comparing a[i] and a[j]
   		//Use a[i].cmp(a[j])
   	}
   }
   

   • Use interfaces to capture capabilities.

Type Consistency

• Lets look at a Polymorphic function to copy an array.

  public static void copyarray(Object[] src, Object[] tgt){
  	int i,limit;
  	limit = Math.min(src.length, tgt.length);
  	for(i=0;i<limit;i++){
  		tgt[i] = src[i];
  	}
  }
  

• Problem: Need to ensure that both the target array and source array are compatible with each other to copy.

  • We are copying objects of src array and storing it in an array tgt.
  • We know that we can store a object which is a subtype in a object of its supertype.
  • So in tgt array we can store:
    1. An object having same type as that of the tgt array.
    2. An object which is a subtype of the type of tgt array.
  • If we just specify the arguments of copyarray method as Object type, then each src and tgt can be any type → Will cause errors during runtime.

Date[] datearr = new Date[10];
Employee[] emparr = new Employee[10];

arraycopy(datearr, emparr); //Causes Runtime Error due to 
														//Incompatible type of objects used for copying!.

• What we need: To make sure that all errors due to incompatible types are captured during compile time.

• In this example → We need to make sure that source array is a subtype(also same type) of target array.

  • Note: The inverse is illegal!
  • Why?:

  public class Ticket {...}
  public class ETicket extends Ticket { ... }
  
  Ticket[] tktarr = new Ticket[10];
  ETikcet[] etktarr = new ETicket[10];
  
  arraycopy(tktarr, etktarr) //illegal -> Because all functionalities of ETicket object is not available for Ticket object.
  

Problem at hand

• Create polymorphic data structures.
  • Array , lists , … should allow arbitrary elements.
• A polymorphic list store values of type Object.