OBJECT ORIENTED

PROGRAMMING
Topic 7:
Polymorphism
TOPIC COVERED

 Polymorphism concept
 Abstract classes and methods

 Method overriding

 Concrete sub classes and methods

POLYMORPHISM CONCEPT

 Polymorphism means “having many

forms”

 It is the ability to use the same name to

refer to methods that perform different
tasks

 Ability of a variable to have more than one

type – hold values of different types.
POLYMORPHISM CONCEPT

 Advantages :-
➢ Allows different (but related) objects the flexibility
to respond differently to the same message.
➢ Allow objects to treat other objects in a general
way.
➢ Code sharing

 Disadvantages :-
➢ When you use it, you must treat different objects in
a general way
➢ Just by looking at the source code, it is not possible
to determine which code is executed.
POLYMORPHISM CONCEPT

To expand the usage and the

effectiveness of polymorphism,
we have to apply the concept
of abstract class and the
array
POLYMORPHISM
PART 1
ABSTRACT
CLASS
ABSTRACT CLASS

 An abstract class is a common solution when we know

the subclass is likely to override the superclass.

 Main reason :-
 To avoid redundant codes
 Several concrete classes have some common code that can be
implemented in a single superclass.

 A class is declared as abstract by including the

keyword abstract in the class’s header line :

public abstract class student { ….. }

ABSTRACT CLASS
VS
CONCRETE CLASS
ABSTRACT CLASS VS CONCRETE CLASS

 Similar to a concrete class :-

➢ Has either public, protected, private or package
accessibility
➢ May include constructors
➢ May include methods, classes and interfaces

 Difference to a concrete class :-

➢ May contain abstract method
➢ Cannot be instantiated
ABSTRACT CLASSES
Student
{abstract}
+NUM_OF_TEST = 2
#name
#test1
#test2
+ Student()
+ Student(String, int, int)
+ getName() : String
+ getTestScore1() : int
+ getTestScore2() : int
+ setName(String) : void
+ setTestScore(int,int) : void

UndergraduateStudent GraduateStudent

Sibling
+UndergraduateStudent (String,
Classes +GaduateStudent (String, int,
int, int) int)
13
ABSTRACT
METHODS
ABSTRACT CLASSES AND METHODS

 For example,

public abstract class Student

{
…….
abstract public void displayCourseGrade();
abstract public double calcCGPA();
}
16
ABSTRACT CLASSES AND METHODS
EXAMPLE
Student
{abstract}
+NUM_OF_TEST = 2
#name
#test1
#test2
+ Student()
+ Student(String, int, int)
+ getName() : String
+ getTestScore1() : int
+ getTestScore2() : int
+ setName(String) : void
+ setTestScore(int,int) : void
+ displayCourseGrade() : void {abstract}

UndergraduateStudent GraduateStudent

Sibling
+UndergraduateStudent (String,
Classes +GaduateStudent (String, int,
int, int) int)
+ displayCourseGrade() : void + displayCourseGrade () : void
17
METHOD
OVERRIDING
METHOD OVERRIDING

 The overriding method must have the same

name, same arguments and same return type
as the overridden method.

 Generally to override the abstract method.

 Can occur in two different forms :-

 Replacement
 A method can replace the method in parent class. Code in
parent class is not executed at all.
 Refinement
 Combines the code from parent and child class – the use of
keyword super (constructor)
ABSTRACT CLASSES AND METHODS
EXAMPLE
public abstract class Card {
protected String recipient;

public Card (String r)

{ recipient = r; }

public abstract void greeting(); class HariRaya extends Card {

} //end Card public HariRaya(String r)
{ super(r); }
-----------------------------------------------------
public void greeting()
class Birthday extends Card { { System.out.println(“Dear “ +
private String date; super.recipient + “ , \n Selamat Hari
Raya”); }
public Birthday(String r, String d)
{ super(r); date =d; } }//end HariRaya

public void greeting()

{ System.out.println(“Dear “ +
super.recipient + “ , \n Happy
Birthday ” + date); }
} //end Birthday
TEST YOURSELF
TEST YOURSELF
1. Define an abstract Actor class with abstract
method caclAllowanceReceived().

2. Override the method

caclAllowanceReceived() in the subclasses
PartTimeActor and FullTimeActor – USING
PREVIOUS CALCULATION.
POLYMORPHISM
PART 2
DYNAMIC
BINDING
DYNAMIC BINDING

 You can indirectly create a reference to a superclass abstract

object.

 A reference is not an object but it points to a memory address

– create variable name that hold the memory address of a
concrete object.

 Whenever you code

CLASSNAME objectName;
you are created a reference to object, then you code
objectName = new CLASSNAME;
you actually set aside memory for the objectName
DYNAMIC BINDING EXAMPLE

Animal
{abstract}
#ownerName : String

+ Animal(String)
+ speak() : void {abstract}

Cow Cat

+Cow(String) +Cat(String)
+ speak() : void + speak() : void
DYNAMIC BINDING EXAMPLE

public class AnimalApp

{ ****The variable ref is a
public static void main (String args[]) type of Animal, but no
superclass Animal object
{
is created, instead Cat
Animal ref;
and Cow objects are
created using the keyword
ref = new Cow(“Abu”); new.
ref.speak();

ref = new Cat(“Ali”);

ref.speak()
}
}
ARRAY IN
POLYMORPHISM
ARRAY IN POLYMORPHISM

 Similar to implement the array in the

inheritance concept. But we want the reference of
array which is comes from the parent class.

 You might want to create a superclass reference

and treat subclass objects as superclass objects so
you can create an array of different objects that
share the same ancestry.

 Manipulate an array of subclass objects by

invoking the appropriate method for each
subclass.
ARRAY IN POLYMORPHISM EXAMPLE
class HariRaya extends Card {
public HariRaya(String r)
{ super(r); }
public abstract class Card {
private String recipient; public void greeting()
{ System.out.println(“Dear “ +
public Card (String r) super.recipient + “ , \n Selamat Hari
{ recipient = r; } Raya”); }

public abstract void greeting(); }//end HariRaya

} //end Card

The application class :

class Birthday extends Card {
private String date; class CardApp {
public static void main(String[] args) {
public Birthday(String r, String d) Card c [] = new Card [2];
{ super(r); date =d; } c[0] = new Birthday(“Rashid”, “2/3/2013”);
c[1]= new HariRaya(“Siti”);
public void greeting() c[0].greeting();
{ System.out.println(“Dear “ + c[1].greeting();
super.recipient + “ , \n Happy }
Birthday ” + date); } } //end CardApp
} //end Birthday
ARRAY IN POLYMORPHISM

The application class :

class CardApp
{
public static void main(String[] args)
{
Card c [] = new Card [2];

c[0] = new Birthday(“Rashid”, “2/3/2013”);

c[1]= new HariRaya(“Siti”);

c[0].greeting();
c[1].greeting();
}
} //end CardApp
ARRAY IN POLYMORPHISM

 From the previous slide example – CardsApp

class CardApp
{
public static void main(String[] args)
{

Card[] c = new Card[2];

c[0] = new Birthday(“Rashid”, “2/3/2013”);

c[1]= new HariRaya(“Siti”);

for (int j = 0; j <2; j++)

{ c[j].greeting(); }

} //end CardApp
ARRAY OF
SUPERCLASS
ARRAY OF SUPERCLASS

 Array of different objects that share the same

superclass.

 The objects in the array has access to the same

method of the superclass.
ARRAY OF SUPERCLASS

 Can be declared to hold objects of different

subclasses.

35
Before creating the object, ask
the user what type of object to
be created!
EXAMPLE :

public class AnimalArray

{
public static void main(String args[])
{
Animal[] ref = new Animal[2];

ref[0] = new Cow(“Abu”);

ref[1] = new Cat(“Ali”);

ref[0].speak();
ref[1].speak();

}
}
EXAMPLE (INPUT) :
public class AnimalArray {
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
Animal[] ref = new Animal[2];

for (int i=0; i<2; i++) {

System.out.print(“Animal type:[ cow / cat] : ");
String type = in.next();

if (type.equals.(“cow”) ) {
ref[i] = new Cow(“Abu”);
}
else if (type.equals.(“cat”) ) {
ref[i] = new Cat(“Ali”);
}
}
for (int i=0; i<2; i++) {
ref[i] .speak();
}
}
}
TEST YOURSELF
TEST YOURSELF

1. Define an application class to

 Create 10 objects of Actor and store the data
into the objects.
 Let the user decide subclasses instantiation
type for the 10 actors.
 Find each actor’s payment.
POLYMORPHISM
PART 3
OPERATOR
INSTANCEOF
OPERATOR INSTANCEOF

 Is used to determine the class of an object (which

subclass is currently point by object reference of
superclass) – filter after creating (instantiation
/new)

 Example

Card c = new Birthday();

if( c instanceof Birthday )

{ System.out.println(“C is a Birthday Card”); }
else
{ System.out.println(“C is other Card”); }
OPERATOR INSTANCEOF (OUTPUT)

class CardApp
{
public static void main(String[] args)
{
Card c [] = new Card [2];
c [0] = new Birthday(“Rashid”, “2/3/2013”);
c [1]= new HariRaya(“Siti”);

for (int i=0; i<2; i++)

if( c[i] instanceof Birthday )
c[i].greeting();
}
}
CASTING
CASTING

 Casting is taking an Object of one particular type

and “turning it into” another Object type.

 To ensure the certain methods can be used

through sub-class definition.

*** Used when there is/are extra method(s) in the

certain subclass.
WITHOUT CASTING
class HariRaya extends Card {
public HariRaya(String r)
{ super(r); }
public abstract class Card {
protected String recipient; public void greeting()
{ System.out.println(“Dear “ +
public Card (String r) super.recipient + “ , \n Selamat Hari
{ recipient = r; } Raya”); }

public abstract void greeting(); }//end HariRaya

} //end Card

The application class :

class Birthday extends Card {
private String date; class CardApp {
public static void main(String[] args) {
public Birthday(String r, String d) Card c [] = new Card [2];
{ super(r); date =d; } c[0] = new Birthday(“Rashid”, “2/3/2013”);
c[1]= new HariRaya(“Siti”);
public void greeting()
{ System.out.println(“Dear “ + for (int j = 0; j <2; j++)
super.recipient + “ , \n Happy c[j].greeting();
Birthday ” + date); } }
} //end Birthday } //end CardApp
CASTING EXAMPLE
public abstract class Card {
protected String recipient;

public Card (String r)

{ recipient = r; }

public abstract void greeting();

} //end Card

class Birthday extends Card {

private String date;

public Birthday(String r, String d)

{ super(r); date =d; }

public void greeting()

{ System.out.println(“Dear “ + super.recipient + “ , \n Happy Birthday ” + date); }

public void partyDate()

{ System.out.println(“Date of the party:” + date); }

} //end Birthday
CASTING EXAMPLE
//Application class
.
.
.
for (int i=0; i<2; i++)
{
//instanceof (filter)
if( c[i] instanceof Birthday )
{
//casting
Birthday tempB = (Birthday) c[i] ;
tempB. partyDate();
}
}
TEST YOURSELF
TEST YOURSELF
1. Add a new method to PartTime Actor named
calcOvertimeReceived() by return the
overtime receive if hour works more than
8 hour with payment RM10.00 per hour.

2. Define an application class to create 10 objects

of Actor to :
a) Input data into the subclasses.
b) Find each full time actor’s payment.
c) Find the maximum overtime received by the part
time actors.
d) Find the average allowance received by all actors.
END.
Thank you.