Polymorphism

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

public abstract class Vehicle{ String name;

public String getName() { return name; } \\ method body

abstract public void move(); \\ no body!

}

An abstract class often contains abstract methods, though it doesn’t have to Abstract methods consist of only methods declarations,

without any method 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 Christmas();

Holiday

Christmas

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

Can we do the following statements: day.celebrate(); day.listenToChristmasSongs();

Holiday day;day = new Christmas();

class Holiday{ public void celebrate() {…}}class Christmas extends Holiday{ public void celebrate() {…} public void listenToChristmasSongs() {…}}

7

References and Inheritance• We can “promote” an object back to its

original type through an explicit narrowing cast:

Holiday day = new Christmas();day.celebrate();…

Christmas c = (Christmas) day;c.listenToChristmasSongs();

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

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);}

interface is a reserved word

No method in aninterface has a definition (body)

A semicolon immediatelyfollows each method header

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 () { // whatever }

// etc.}

implements is areserved word

Each method listedin 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)

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

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.

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.

A Class Hierarchy

Animal

Dog Cat Fish

Mutt Poodle Gold Beta

A Polymorphic Example

Animal

Dog

Mutt

MyMutt isoftype MuttMyAnimal isoftype AnimalMyDog isoftype Dog. . .MyDog <- MyMuttMyAnimal <- MyMutt

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.

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

Method Calls and Polymorphism

Assume the Dog class inherits the Animal class, redefining the “MakeNoise” method.

Consider the following:

MyAnimal <- MyDogMyAnimal.MakeNoise

Method Calls and Polymorphism

MyAnimal <- MyDogMyAnimal.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.

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

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

The Banking Class Hierarchy

Cool Savings

Bank Account

Savings Account

Checking Account

NOW Account

Money Market Account

CD Account

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.

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)

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

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

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

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.

Explain how you would program this