1. Polymorphism

2. Abstract Classes Java allows abstract classes
use the modifier abstract on a class header to declare an abstract class abstract class Vehicle { … }
An abstract class is a placeholder in a class hierarchy that represents a generic concept
Vehicle
Car
Boat
Plane

3. Abstract Class: Example
An abstract class often contains abstract methods, though it doesn’t have to
Abstract methods consist of only methods declarations, without any method body
public abstract class Vehicle
{ String name;
public String getName()
{ return name; } \\ method body
abstract public void move();
\\ no body! }

4. Abstract Classes
An abstract class often contains abstract methods, though it doesn’t have to
Abstract methods consist of only methods declarations, without any method body
The non-abstract child of an abstract class must override the abstract methods of the parent
An abstract class cannot be instantiated
(why?)
The use of abstract classes is a design decision; it helps us establish common elements in a class that is too general to instantiate

5. Recap: References and Inheritance
An object reference variable can refer to any object instantiated from
its own class, or
any class derived from it by inheritance
For example,
Holiday day;
day = new Holiday(); …
day = new Thanksgiving();
Holiday
Thanksgiving
The assignment of an object of a derived class to a reference variable of the base class can be considered as a widening conversion

6. References and Inheritance
Through a given type of reference variable, we can invoke only the methods defined in that type
class Holiday { public void celebrate() {…} }
class Thanksgiving extends Holiday {
public void celebrate() {…} public void eatTooMuch() {…} }
Holiday day;
day = new Thanksgiving();
Can we do the following statements?
day.celebrate();
day.eatTooMuch();

7. References and Inheritance
We can “promote” an object back to its original type through an explicit narrowing cast:
Holiday day = new Thanksgiving();
day.celebrate(); …
Thanksgiving t = (Thanksgiving) day;
t.eatTooMuch();
Question: which celebrate() will be invoked by the line:
day.celebrate();

8. Java Interface
A Java interface is a collection of constants and abstract methods
abstract method: a method header without a method body; we declare an abstract method using the modifier abstract
since all methods in an interface are abstract, the abstract modifier is usually left off
Methods in an interface have public visibility by default

9. Interface: Syntax interface is a reserved word public interface Doable{
public static final String NAME;
public void doThis();
public int doThat();
public void doThis2 (float value, char ch);
public boolean doTheOther (int num); }
A semicolon immediately
follows each method header
No method in an
interface has a definition (body)

10. Implementing an Interface
A class formally implements an interface by
stating so in the class header in the implements clause
a class can implement multiple interfaces: the interfaces are listed in the implements clause, separated by commas
If a class asserts that it implements an interface, it must define all methods in the interface or the compiler will produce errors

11. Implementing Interfaces
public class Something implements Doable {
public void doThis ()
// whatever }
public void doThat ()
// etc.
implements is a
reserved word
Each method listed
in Doable is
given a definition
public class ManyThings implements Doable, AnotherDoable

12. Interfaces: Examples from Java Standard Class Library
The Java Standard Class library defines many interfaces:
the Iterator interface contains methods that allow the user to move through a collection of objects easily
hasNext(), next(), remove()
the Comparable interface contains an abstract method called compareTo, which is used to compare two objects
if (obj1.compareTo(obj2) < 0) System.out.println(“obj1 is less than obj2”);

13. Polymorphism via Interfaces
Define a polymorphism reference through interface
declare a reference variable of an interface type Doable obj;
the obj reference can be used to point to any object of any class that implements the Doable interface
the version of doThis depends on the type of object that obj is referring to:
obj.doThis();

14. Interface Hierarchies
Inheritance can be applied to interfaces as well as classes
One interface can be used as the parent of another
The child interface inherits all abstract methods of the parent
A class implementing the child interface must define all methods from both the parent and child interfaces
Note that class hierarchies and interface hierarchies are distinct (they do not overlap)

15. Scenarios
A veterinarian's algorithm might have a list of animals, but each one needs different food or care… we want ONE information system to track all of this without complex logic for each individual kind of animal.
A car dealership sells many different types of cars with different features, but each has a price and quantity in stock.
A registration system might treat in-state students differently from out-of-state students, graduate students differently from undergraduates, etc.
A graphical user interface (GUI) e.g. Windows needs to puts lots of simlar widgets on screen... LB

16. Motivation
We’d like to be able to manage objects of different kinds of classes.
Since classes within a class hierarchy often share common methods and attributes, we’d like to make use of this fact to make our algorithms simpler.

17. Polymorphism Defined The ability to take on different forms.
Manipulate objects of various classes, and invoke methods on an object without knowing that object’s type.

18. A Class Hierarchy
Animal
Dog
Cat
Fish
Mutt
Poodle
Gold
Beta

19. A Polymorphic Example Animal Dog MyMutt isoftype Mutt
MyAnimal isoftype Animal
MyDog isoftype Dog
. . .
MyDog <- MyMutt
MyAnimal <- MyMutt
Mutt

20. Polymorphism Explained
MyAnimal <- MyMutt seems incorrect. The left and right hand side of the assignment seem to not match; or do they?
Since Mutt inherits from Dog, and Dog inherits from Animal, then MyMutt is at all times a Mutt, a Dog, and an Animal. Thus the assignment statement is perfectly valid.
This makes logical (“real world”) sense.

21. An Illegal Example
We are able to assign an object of a sub-class into an object of a super-class as in:
MyAnimal <- MyMutt
But the reverse is not true. We can’t assign a superclass object into a sub-class object.
MyMutt <- MyAnimal // illegal

22. Method Calls and Polymorphism
Assume the Dog class inherits the Animal class, redefining the “MakeNoise” method.
Consider the following:
MyAnimal <- MyDog
MyAnimal.MakeNoise

23. Method Calls and Polymorphism
MyAnimal <- MyDog
MyAnimal.MakeNoise
Different languages handle this differently.
For simplicity, we’ll assume that MyAnimal “remembers” it is actually an object of the Dog class, so we’ll execute the MakeNoise method in the Dog class.

24. Polymorphism vs. Inheritance
Inheritance is required in order to achieve polymorphism (we must have class hierarchies).
Re-using class definitions via extension and redefinition
Polymorphism is not required in order to achieve inheritance.
An object of class A acts as an object of class B (an ancestor to A).

25. Processing Collections
One of the main benefits of polymorphism is the ability to easily process collections.
We will consider a collection (queue) of bank accounts in the next example. . .

26. The Banking Class Hierarchy
Cool Savings
Bank Account
Savings Account
Checking Account
NOW Account
Money Market Account
CD Account

27. A Collection of Bank Accounts
Imagine a bank needs to manage all of the accounts.
Rather than maintain seven separate queues, one each for: Bank_Accounts, Savings_Accounts, Cool_Savings, CD_Accounts, Checking_Accounts, NOW_accounts, and Money_Market_Accounts
We can maintain only one queue of Bank Accounts.

28. Polymorphic Banking Assume accounts of various kinds:
john_account isoftype Checking_Account
paul_account isoftype Cool_Savings
paul_other_account isoftype CD_Account
george_account isoftype NOW_Account
ringo_account isoftype Money_Market
Then put them all in a single structure:
account_queue isoftype Queue(Bank_Account)
account_queue.Enqueue(john_account)
account_queue.Enqueue(paul_account)
account_queue.Enqueue(paul_other_account)
account_queue.Enqueue(george_account)
account_queue.Enqueue(ringo_account)

29. Polymorphic Banking account_queue is polymorphic:
It is holding accounts of “many forms.”
Each of the accounts is “within the family” of the class hierarchy of bank accounts.
Each one will have it’s own set of capabilities via inheritance (extension, and/or redefinition).

30. Resolving Polymorphic Method Calls
Different languages do this differently.
The various kinds of Accounts, though all stored as a Bank_Account, remember the class (subclass) of which they are an instance.
So, calls to Get_Balance() will:
use the method from class NOW_Account if the object is an instance of NOW_Account
use the method from class Money_Market if the object is an instance of Money_Market
and so on...

31. Polymorphism
This is the “magic” of polymorphism…it keeps track of family members within the inheritance hierarchy for you.
Without it, we’d have lots of code sprinkled through out our algorithm choosing among many options:
if( it’s Checking_Account ) then
call Checking_Account Calc_Interest
elseif( it’s Super_Savings) then
call Super_Savings Calc_Interest
elseif( it’s CD_Account then
call CD_Account Calc_Interest
elseif( it’s NOW_Account ) then
call NOW_Account Calc_Interest
. . .

32. Summary
Polymorphism allows objects to represent instances of its own class and any of its sublcasses.
Polymorphic collections are useful for managing objects with common (ancestor) interfaces.
For our purposes, we’ll assume objects “remember” what kind of class they really contain, so method calls are resolved to the original class.

33. Explain how you would program this

34. Classes, interfaces polymorphism
P 9.3, 9.8, 9.13 (random shape) pg
P 10.7 pg 493 (inheritance)