Polymorphism

interface Collection {
	...
	int size();
	...
}

interface List extends Collection {
	...
}

interface Set extends Collection {
	...
}

class Vector implements List { // ... and thus also Collection
	...
}

class HashSet implements Set { // ... and thus also Collection
	...
}

	Collection c = new HashSet();	// upcast-- legal-- HashSet implements Collection and therefore is a Collection
	System.err.println(c.size());

• Can't be one from Collection-- Collection is an interface-- method spec only -no body (implementation)
• Can't be one from Set -- Set is an interface as well
• The size method of HashSet is invoked.
  • This is known a polymorphism -- method invocation is performed based on the object (the HashSet in this case, not the reference variable (Collection).
  • Polymorphism means many faces-- the reference variable can present different behavior depending upon the object it is referring to.

Thus, if we then write

	c = new Vector(); // upcast-- legal-- Vector implements Collection and therefore is a Collection
	System.err.println(c.size());

Revisiting the Employee Class

We can examine polymorphism in the Employee class presented in the context of abstract classes.

abstract class Employee {
	Employee(Name name, String ssNum) {...}
	...
	abstract void doPayroll();
 	...
	Name name;
	String ssNum;
	Date hiredOn;
}

class FactoryWorker extends Employee {
	FactoryWorker(Name name, String ssNum, Currency hourlyRate) {
		super(name, ssNUm);
		this.hourlyRate = hourlyRate;
	}
	...
	void doPayroll() {
		...
	}
	...	
	...
	
	double hourlyRate;
}

class OfficeWorker extends Employee {
	OfficeWorker(Name name, String ssNum, Currency annualSalary) {
		super(name, ssNUm);
		this.annualSalary = annualSalary;
	}
	...
	void doPayroll() {
		...
	}
	...	
	Currency annualSalary;
}

	Employee [] employees;
	...
	
	for (int i = 0; i < employees.length; i++)
		employees[i].doPayroll();