Polymorphism and Interfaces - Universitetet i Bergenkhalid/jac/pdf/ls-13-polymorphism...Java Actually 13: Polymorphism and Interfaces 13-5/26 Dynamic method lookup † When a method

J 13-1/26

erfaces

Programmingen

conjunction with the book.

ava Actually 13: Polymorphism and Interfaces

Chapter 13

Polymorphism and Int

Lecture slides for:

Java Actually: A Comprehensive Primer in Khalid Azim Mughal, Torill Hamre, Rolf W. Rasmuss

Cengage Learning, 2008.

ISBN: 978-1-844480-933-2http://www.ii.uib.no/~khalid/jac/

Permission is hereby granted to use these lecture slides in

Modified: 16/2/19

J 13-2/26

ct classes:nstantiation and inheritance

ethod overridingoncrete classes

ance versus aggregation

ution principle - Liskov


Topics

Programming using inheritance:– One superclass with several

subclasses– Polymorphism and dynamic

method lookup– Using polymorphic references– Consequences of polymorphism

Interfaces in Java– Abstract methods– Interface types– Multiple inheritance for

interfaces– Interfaces and polymorphic

references– Super- and subinterfaces

Abstra– I– M– C

Inherit

Substit

J 13-3/26

ance declare new fields and hide

plement the abstraction of the

PieceWorkerV0

numUnitspayPerUnit

printState()calculateSalary()


Programming using inherit• A superclass often has multiple subclasses, which can

inherited fields, and override instance methods to imsubclass.

HourlyWorkerV0 ManagerV0

EmployeeV0

NORMAL_WORKWEEK

printState()calculateSalary()

firstNamelastName

managerBonus

calculateOvertime()

hourlyRate

calculateSalary()

calculateSalary()printState()

J 13-4/26

cution cannot always be

3=manager, 4=piece worker):"); n", "Doe", 30.0); erV0("Mary", "Smith", 35.0); John D.", "Boss", 60.0, 105.0); rV0("Ken", "Jones", 12.5, 75); .50); after the if statement?

ence employee will denote after

objects of different classes

refer to objects of all subclasses


Polymorphic references• Which object a reference denotes during program exe

determined during compilation. ... EmployeeV0 employee; Scanner keyboard = new Scanner(System.in); System.out.println("Choose a category " + "(1=employee, 2=hourly worker, int selection = keyboard.nextInt(); if (selection == 1) employee = new EmployeeV0("Joh else if (selection == 2) employee = new HourlyWork else if (selection == 3) employee = new ManagerV0(" else if (selection == 4) employee = new PieceWorke else employee = new EmployeeV0("Ken", "Harris", 25 // Which object does the employee reference denote ...

• The compiler cannot determine which object the referthe if statement above.

• A polymorphic reference is a reference that can refer to (types) at different times.– A reference to a superclass is polymorphic since it can

of the superclass during program execution.

J 13-5/26

p the object (i.e. object type) and the ion is executed.s the object is not relevant.

the if statement? teSalary() method is executed? te() method is executed here?

hich method definition a method ss of the object.rchy upwards to find the method

ethod in the class that the object ll, the printState() method in referred to employee belongs to se, the printState() method in ependent on whether employee


Dynamic method looku• When a method is called for an object, it is the class of

method signature that determines which method definit– The type of the reference (i.e. declared type) that denote

... // Which object does employee denote at the end of System.out.println("Weekly salary=" + employee.calculateSalary()); // Which calcula employee.printState(); // and which printSta ...

• Dynamic method lookup is the process that determines wsignature denotes during execution, based on the cla– This process can lead to searching the inheritance hiera

definition.– For the first call above, the calculateSalary() memployee refers to will be called. For the second cathe EmployeeV0 class will be executed, if the objectthe EmployeeV0 or HourlyWorkerV0 class. Otherwione of the two other subclasses will be executed, ddenotes a manager or a piece worker.

J 13-6/26

ces

// (1)

,),

5.0 }; // (2)

ected properties for each

.2f GBP%n", // (3) // (4)); // (5)


Using polymorphic referenclass EmployeeArray { // From Program 13.4 static EmployeeV0[] empArray = { new EmployeeV0("John", "Doe", 30.0), new HourlyWorkerV0("Mary","Smith", 35.0), new PieceWorkerV0("Ken", "Jones", 12.5, 75) new ManagerV0("John D.", "Boss", 60.0, 105.0 }; static double[] empHours = { 37.5, 25.0, 30.0, 4

public static void main(String[] args) { // Traverses the employee array and prints sel // employee in the array. for (int i=0; i< empArray.length; i++){ System.out.printf("Employee no. %d: %s %s" + " has a weekly salary of % i+1, empArray[i].firstName, empArray[i].lastName, empArray[i].calculateSalary(empHours[i]) } }}

J 13-7/26

25,00 GBP1312,50 GBP37,50 GBPf 3150,00 GBP


• Program output:Employee no. 1: John Doe has a weekly salary of 11Employee no. 2: Mary Smith has a weekly salary of Employee no. 3: Ken Jones has a weekly salary of 9Employee no. 4: John D. Boss has a weekly salary o

J 13-8/26

hism objects with a common s to one of the subclasses or the

source code to result in different xecution.is called.

e same manner, and there is no re added. ts easier.


Consequences of polymorp• Polymorphism allows us to denote different types of

(polymorphic) reference, as long as these objects belongsuperclass in an inheritance hierarchy.

• Dynamic method lookup causes the same call in the method implementations being executed during program e– The actual type of the object decides which method

• Clients can treat superclass and subclass objects in thneed for changing the client even if new subclasses a– This makes development and maintenance of clien

J 13-9/26

out providing an implementation.

arameter list and return type —

ecify this using the keyword

hods in the interface.


Interfaces in Java• An interface in Java defines a set of services - but with

• The interface contains a set of abstract methods.

• A abstract method is comprised of the method name, pbut no implementation.

• Example:

interface ISportsClubMember { double calculateFee(); // abstract method}

• Classes that want to implement an interface have to spimplements, for instance:class Student implements ISportsClubMember { double calculateFee() { return 100.0; } // ... other methods and fields}

– and provide an implementation of the abstract met

J 13-10/26

s of an interface.

- and we can declare references

all classes that implements the

access to all services that the


Interfaces in Java (cont.)

• An interface is not a class - so we cannot create object

• However, an interface defines a type - an interface typeof this type, e.g.ISportsClubMember student;

• A reference of an interface type can denote objects ofinterface:class EmployeeV1 implements ISportsClubMember { ... double calculateFee() { ... }}...ISportsClubMember member;member = new EmployeeV1("Al", "Hansen", 325.0);...member = new Student("Peter", "Jablonski", 35);

• With an interface type reference we can therefore getinterface defines.

J 13-11/26

ts.

{

ecessary due to implements.

mplemented the interface otation, e.g. tants.



• An interface can also be used to import shared constan

class ImportantClass implements ImportantConstants public int reply() { if (isDone()) return TERMINATE; // Interface name is not n else return CONTINUE; } boolean isDone() { ... }}

• If the class ImportantClass had not declared that it iImportantConstants, it would have to use the dot nImportantConstants.TERMINATE, to access the cons

J 13-12/26

is called multiple inheritance for

IRepresentative {

m every interface.

interface A is called a

ds from both A and B.

ace)rface)



• A class can implement multiple Java interfaces. This interfaces.

class ManagerV1 extends EmloyeeV1 implements ISportsClubMember, ...}

– The class has to implement all abstract methods fro

• A interface B can extend another interface A. Then thesuperinterface and B a subinterface.

• A class that implements B must implement the metho

interface ITick { void tick(); }interface ITickTock extends ITick { void tock(); }

class Watch implements ITickTock { void tick() { ... } // from ITick (superinterf void tock() { ... } // from ITickTock (subinte}

J 13-13/26

Dingding()

Dong

dong()

g { ... }

ing { ... }


Inheritance hierarchy

String

length()substring()

Object

equals()

toString()getClass()

equals()

Pling

ding()

dong()

Plong

class Dong extends Din

class Plong extends Pl

J 13-14/26

multiple typesh ding() and dong() methods.

Dingding()

Dongdong()

refer to a Dong, a Pling and a object.

nterface


Using interfaces to handle objects of • Create a reference type that can denote things with bot

String

length()substring()

Object

equals()toString()notify()

equals()

Pling

ding()dong()

PlongA variable of type DingDong canPlong object, but not to a Ding

DingDong

ding()dong()

Inheritance I

«interface»

J 13-15/26

ultiple types (cont.)

from Ding"); }

from Dong"); }

from Pling"); }from Pling"); }

g fra Plong"); }


Using interfaces to handle objects of minterface DingDong { public void ding(); public void dong();}

class Ding { public void ding() { System.out.println("ding }

class Dong extends Ding implements DingDong { public void dong() { System.out.println("dong }

class Pling implements DingDong{ public void dong() { System.out.println("dong public void ding() { System.out.println("ding }

class Plong extends Pling { public void plong() { System.out.println("plon}

J 13-16/26

p e array of references alising references + dynamic method lookup }


ublic class TestInterface { public static void main(String[] args) { DingDong dingdongs[] = new DingDong[3]; // Creat dingdongs[0] = new Dong(); // Initi dingdongs[1] = new Pling(); dingdongs[2] = new Plong(); for (int i = 0; i < dingdongs.length; i++) dingdongs[i].ding(); // Polymorphic references }

• Program output:ding from Dingding from Plingding from Pling

J 13-17/26

es in Javanterface (implements keyword).

for all abstract methods that are

also implement the interface

ubinterfaces.

s of an interface type are

lement all methods from its

here objects can belong to

inheritance where method and ).

ll implementation difficulties.


Summing up the use of interfac• A class must explicitly declare that it implements an i

• The class (or its subclasses) must implement methodsspecified in the interface.

• If a class implements an interface, all of its subclassesautomatically as a result of inheritance.– Inheritance also applies for interfaces: super- and s

• Interfaces define a new reference type, and referencepolymorphic.

• A class can implement multiple interfaces.

• A class that implements a subinterface must also impsuperinterface.

• Two variants of inheritance:– Design inheritance: Multiple interface inheritance w

multiple types (using interfaces in Java).– Implementation inheritance: Simple implementation

variable lookup is simpler (using subclasses in Java

Almost all advantages of general multiple inheritance without a

J 13-18/26

rough inheritance enforces all

ole) contract defined by a Java

stract methods of the .

subclass objects, and by means e executed.

s ItemWithDiscount is an s Item and ItemWithUnitPrice

an abstract class implements a mplement the parts that are


Abstract classes• An abstract class is a class that cannot be instantiated.

• Abstract classes can be used as a superclass, which thsubclasses to fulfill a common contract.– An abstract class can implement parts of (or the wh

interface.

• A subclass of an abstract class must implement the absuperclass, otherwise it should be declared abstract

• Clients can use references of the abstract class to denoteof polymorphism the correct instance methods will b

• Example: We want to offer discounted items. The clasabstract superclass for all discounted items. The classeare reused.

• Example: Use of the Template Method design pattern -common framework for behaviour; subclasses must ispecific for them.

J 13-19/26

thPercentageDiscount

scount()ng()


Abstract classes (cont.)

ItemWithUnitPrice

unitPrice

getUnitPrice()

Item

itemNameinventory

getItemName() toString()

ItemWithDiscount«abstract»

getInventory()setItemName()setInventory()toString()

findDiscount()

ItemWithFixedDiscount

discount

findDiscount()toString()

ItemWi

findDitoStri

J 13-20/26

p}p before}

p tPrice { price) { lass constructor , int numOrdered);}

p t { uble price, double discount) { rclass constructor GBP."; int numOrdered) {


Abstract classes (cony.)

ublic class Item { // ... as before

ublic class ItemWithUnitPrice extends Item { // ... as

ublic abstract class ItemWithDiscount extends ItemWithUni ItemWithDiscount(String itemName, int inventory, double super(itemName, inventory, price); // calls the superc } abstract double findDiscount(double priceWithoutDiscount

ublic class ItemWithFixedDiscount extends ItemWithDiscoun private double discount; // fixed discount in GBP ItemWithFixedDiscount(String itemName, int inventory, do super(itemName, inventory, price); // calling the supe assert discount >= 0.0: "Item discount must be greater than or equal to 0.0 this.discount = discount; } public double findDiscount(double priceWithoutDiscount, return discount; }

J 13-21/26

the ItemWithUnitPrice class }

p t { uble price, double discount) { rclass constructor GBP."; int numOrdered) { the ItemWithUnitPrice class }


public String toString() { // overrides toString() from return super.toString() + "\tDiscount: " + discount; }

ublic class ItemWithFixedDiscount extends ItemWithDiscoun private double discount; // fixed discount in GBP ItemWithFixedDiscount(String itemName, int inventory, do super(itemName, inventory, price); // calling the supe assert discount >= 0.0: "Item discount must be greater than or equal to 0.0 this.discount = discount; } public double findDiscount(double priceWithoutDiscount, return discount; } public String toString() { // overrides toString() from return super.toString() + "\tDiscount: " + discount; }

J 13-22/26

p scount { old to get a discount reased by for each interval t y, double price, simalSats) { sens konstruktør be > 0"; interval"; e >= 0%"; int numOrdered) { ; "; the ItemwithUnitPrice class scountInterval e: " + maxPercentage;


ublic class ItemWithPercentageDiscount extends ItemWithDi int discountInterval; // number of items that must be s double percentage; // percentage the discount is inc double maxPercentage; // maximum percentage for discoun ItemWithPercentageDiscount(String itemName, int inventor int discountInterval, double prosentSats, double mak super(itemName, inventory, price); // kaller superklas assert discountInterval > 0 : "Discount interval must assert percentage >= 0.0 : "Discount msut be >= 0% per assert maxPercentage >= 0.0 : "Maximum discount must b this.discountInterval = discountInterval; this.percentage = percentage; this.maxPercentage = maxPercentage; } public double findDiscount(double priceWithoutDiscount, int numIntervals = numOrdered / discountInterval; double discount = numIntervals * percentage; if (discount > maxPercentage) discount = maxPercentage assert discount >= 0.0 : "Given discount must be >= 0% return discount/100.0*priceWithoutDiscount; } public String toString() { // overrides toString() from return super.toString() + "\tDiscount interval: " + di + "\tPercentage: " + percentage + "\tMaximum percentag }}

J 13-23/26

p , .50, 0.50), ), 50, 2.00, 0.75), 500, 1.50, ]; i]); s of item '" " GBP.");


ublic class Sales { public static void main(String[] args) { ItemWithUnitPrice[] stock = { new ItemWithUnitPrice("Coca cola 0.5l", 150, 3.50) new ItemWithFixedDiscount("Pepsi Max 0.5l", 100, 3 new ItemWithUnitPrice("Pepsi Light 0.5l", 50, 3.00 new ItemWithFixedDiscount("Sparkling water 0.5l", new ItemWithPercentageDiscount("Coca cola 0.33l", 10, 0.5, 10.0) }; int[] order = { 50, 50, 10, 20, 250 }; double total = 0; double discount = 0; double itemPrice, itemDiscount; for (int i=0; i<stock.length; i++) { itemPrice = stock[i].getUnitPrice(); itemDiscount = 0; if (stock[i] instanceof ItemWithDiscount) { ItemWithDiscount item = (ItemWithDiscount) stock[i itemDiscount = item.findDiscount(itemPrice, order[ itemPrice -= itemDiscount; itemDiscount *= order[i]; // for the whole order } itemPrice *= order[i]; // for the whole order System.out.println("Price for " + order[i] + " piece + stock[i].getItemName() +"' is " + itemPrice +

J 13-24/26

has been subtracted."); }

PPP .P GBP.P P.TD


total += itemPrice; discount += itemDiscount; } System.out.println("Total amount: " + total+ " GBP."); System.out.println("Discount of: " + discount + " GBP }

• Program output:

rice for 50 pieces of item 'Coca cola 0.5l' is 175.0 GBP.rice for 50 pieces of item 'Pepsi Max 0.5l' is 150.0 GBP.rice for 10 pieces of item 'Pepsi Light 0.5l' is 30.0 GBPrice for 20 pieces of item 'Sparkling water 0.5l' is 25.0rice for 250 pieces of item 'Coca cola 0.33l' is 375.0 GBotal amount: 755.0 GBP.iscount of: 40.0 GBP has been subtracted.

J 13-25/26

tionses access to fields and methods

up in the inheritance hierarchy).

asses to declare composite objects (a.k.a. constituent objects).

class.l class).

sses have already been declared

class).

r inheritance we need to use the


Inheritance versus aggrega• Inheritance offers reuse of classes by allowing new clas

from the superclass (and all other superclasses further

• Aggregation offers reuse of classes by allowing new clwhere objects of existing classes are included as parts

• Use inheritance when:– the new class is a logical specialisation of an existing– the existing class can be extended (i.e. is not a fina

• Use aggregation when:– the new class represents composite objects, and cla

for the part-objects.– an existing class cannot be extended (i.e. is a final

Note that aggregation if offered by default in Java, while fokeyword extends.

J 13-26/26

kov

ave one or more supertypes. The .

cation of their supertypes, meaning ject.


Substitution principle - Lis• A reference type can be:

– a class name– an interface name– an array type

• Subtypes and supertypes:– In the inheritance hierarchy, a reference type can h

reference type is a subtype of each of its supertypes

• Substitution principle:

The behaviour of subtypes is in accordance with the specifithat a subtype object can be substituted for a supertype ob

Polymorphism and Interfaces - Universitetet i Bergenkhalid/jac/pdf/ls-13-polymorphism...Java Actually 13: Polymorphism and Interfaces 13-5/26 Dynamic method lookup † When a method

Documents