Polymorphism

Contents

1. Forms of polymorphism
2. Polymorphic variables – late (run-time binding)
3. Abstract classes – example, Shape
4. Inheritance and polymorphism
 Polymorphism

Forms of poymorphism

operator overloading

Exmple – the + operator has different

implementations with different arguments

parametric overloading

Example – overloading sqr in java.Math

polymorphic variables
 The Object-oriented Programming Paradigm

Polymorphic Variables
Shape
Shape is an abstract class
area()
with no implementation of
perimeter()
area() and perimeter()

Rectangle
Circle
area()
area()
perimeter()
perimeter()

Circle and Rectangle are concrete classes with their own separate
implementations of the methods area() and Perimeter()
 The Object-oriented Programming Paradigm
Abstract Classes
There can berealizations
Concrete NO instances of an
of Shape
public abstract class Shape { Abstract Shape class
abstract class (no Shape objects)
protected String shapeName;
Class MUST be qualified as
public Shape(String name) {shapeName = name;} abstract if one or more
public abstract double area ( ); methods are abstract
public abstract double perimeter ( );
public String toString( ) {return shapeName;};
} public class Circle extends Shape {
public class Rectangle extends Shape{ private double radius;
protected double length, width; public Circle (double rad) {
public Rectangle(double len, double wid) { super (“Circle”);
super(“Rectangle”); radius = rad;
length = len; width = wid; }
} public double area( ) {
public double area ( ) {return length * width;} return Math.PI * radius * radius; }
public double perimeter ( ) { public double perimeter( ) {
return 2.0 * (length + width); } return 2.0 * Math.PI * radius; }
} }
 The Object-oriented Programming Paradigm
Additional inheritance Square extends Rectangle
public class Square extends Rectangle {
Shape public Square (double side) {
super (“Square”);
Attributes inherited
from Rectangle length = width = side;
}
}
BUT! There is a problem!
Circle Rectangle super(“Square”); refers to
the base class of Square –
which is Rectangle.
We need to add a constructor:
Rectangle(String name) {
Add a class Square Square super(name);
to the collection of }
shapes. to class Rectangle -- to “pass the
string Square” up to the base class.
 The Object-oriented Programming Paradigm

A vector of Shapes

A container of Shape objects will execute their own area

and perimeter methods
 The Object-oriented Programming Paradigm
Example (an array of Shapes)
public class ShapeShifter {
public static void main (String [ ] args) {
Create an array to hold objects of
Shape [ ] shapeList = new Shape[5]; (derived from) class Shape
shapeList[0] = new Circle(3.0);
shapeList[1] = new Rectangle(3.0, 4.0); Create objects of the derived
shapeList[2] = new Rectangle(2.5, 7.5); classes and put them in
shapeList[3] = new Circle(2.5); shapeList
shapeList[4] = new Square(5.0);
for (int i = 0; i < shapeList.length; i++) { Iterate through the list
System.out.print (shapeList[i].toString( ) + “ ” ); and show area and
perimeter of shapes
System.out.print (shapeList[i].area( ) + “ ”);
System.out.println (shapeList[i].perimeter( ));
}
}
Each derived class object executes its own area and perimeter methods
}
 The Object-oriented Programming Paradigm
Inheritance

Consider a class Animal:

Animal
private String name;
Attributes
private String says;
public Animal(String str, String s2){ Constructor
name = new String(str);
says = new String(s2);
}

public void speak( ) { Behavior

System.out.println(name+says);
}
 The Object-oriented Programming Paradigm
Inheritance
Animal serves as the base class for several derived classes
public class Dog extends Animal { public class Bird extends Animal {
public Dog(String says ) { public Bird(String says) {
super(“Dog”, says); super(“Bird”,says);
} }
public void move ( ) { public void move ( ) {
System.out.println(“ -- I run”); System.out.println(“ -- I fly”);
} }
} Initialize base class attributes

New methods can extend the behavior of the base class

 The Object-oriented Programming Paradigm
Inheritance
Animal Base class
String name;
String says;

public Animal(String, String)

public void speak( )

Derived classes
extend the base class

Dog Bird
public Dog(String) public Bird(String)
public void move( ) public void move( )
 The Object-oriented Programming Paradigm
Inheritance
Consider the following application (class AnimalHouse)
public class AnimalHouse { public static void main(String [ ] args) {
private Dog Lassie; AnimalHouse zoo = new AnimalHouse( );
private Bird TweetyBird; zoo.animalAct( );
private Animal Felix; }
public AnimalHouse ( ) { }//end class AnimalHouse
Lassie = new Dog(“ -- bow-wow”);
TweetyBird = new Bird(“ -- tweet-tweet”);
Felix = new Animal(“Cat”, “ – meoow”); The class contains
Output
Theapplication
constructor three
allocates
The class
} attributes
memory for (“data”
the members)
three private
(AnimalHouse) contains a main
that are objects
Dog -- bow-wow
objects of the
and initializes base
public void animalAct( ) { function that creates antheir
Lassie.speak( ); class Animal, or one of the
attributes.
instance of the class and tells
Bird --derived
tweet-tweet
TweetyBird.speak( ); classes from it.
the AnimalHouse object zoo to
Felix.speak( ); Cat -- its
execute meoow
animalAct( )
Lassie.move( ); operation.
-- I run
TweetyBird.move( );
} -- I fly
Felix cannot receive a message move( )
 The Object-oriented Programming Paradigm
Composition

Consider the class Counter described below

public class Counter {
private int count, base;
public Counter(int baseVal) {…}
public void increment( ) {…}
public void reset( ) {…}
public int viewCount( ) {…}
}

We may use composition to build a Clock out of Counter objects

 The Object-oriented Programming Paradigm
Composition

public class Clock {

These Counter objects are not
private Counter hours, mins, secs;
accessible outside of a Clock object.
public Clock( )
hours = new Counter(24);
mins = new Counter(60);
Each Clock object must hold
its own set of Counter objects
secs = new Counter(60);
}
public void tick( ) { Clock methods are
secs.increment( ); implemented by the Counter
if (secs.viewCount( ) == 0) { components
mins.increment( );
if((secs.viewCount( )==0) && (mins.viewCount( ) == 0))
hours.increment( );
}
In an assignment you will add methods set( ) and
}
viewHr(), viewMin( ), and viewSec( ) to this class
}
 The Object-oriented Programming Paradigm
Inheritance
Suppose we want to construct a new class called AlarmClock that has
all of the features of a Clock, but adds an alarm as well.
public class AlarmClock extends Clock { Inherits from class Clock
private boolean alarmOn;
Additional attributes in an AlarmClock
private int hrSet, minSet;
public AlarmClock( ) {alarmOn = false;} //the alarm is not set initially
public void setAlarm(int hr, int min) { Additional methods in AlarmClock
hrSet = hr; minSet = min; alarmOn = true;
}
public void tick( ) { Override the implementation of tick( ) in parent
super.tick( ); Execute the version of this method in the parent class

if ((viewHr( ) == hrSet)&&(viewMin() == minSet)&&alarmOn){

System.out.println(“ring, ring, ring”);
viewHr() and viewMin( )
} are methods in an
public void resetAlarm( ) {alarmOn = false;} AlarmClock that are
} inherited from its parent
 The Object-oriented Programming Paradigm
Inheritance

The constructor AlarmClock( ) initializes the boolean variable

alarmOn to false, and leaves the initial alarm settings at the default
values – hrSet = 0 and minSet = 0. The constructor for the base class
does not take any parameters, and no additional initialization is
needed to instantiate the three Counter objects.

The method tick( ) is overriden in the derived class. After every tick
of the clock, a test is done to see whether it is time for the alarm to go
off. The methods viewHr( ) and viewMin( ) are inherited from the
base class and are available to any client of an AlarmClock object
(including the methods of this class).
 The Object-oriented Programming Paradigm
Polymorphism and Genericity

Genericity
The only container object we have studied so far is the array. Arrays of
any type can be declared, and the array operations such as
•Assignment ex. A[0] = assigned value of the declared type.
•Retrieval ex. Itemtype myVar = A[3]; //retrieve object at index 3
•Length A.length
are syntactically independent of the type being stored in the array.

We will have a need to construct (or use) various other container

classes; and objects of container classes should be capable of
holding any kind of object and provide the same functionality to
the user regardless of their contents.
 The Object-oriented Programming Paradigm
Polymorphism

There are a variety of forms that polymorphism may take:

1. Overloading of function names.

functions with different parameter lists may have the same identifier
Ex: public static int sqr(int x) {…}
public static double sqr(double x) {..}
The compiler determines which function to use by the type of the argument in
the function call.
An operation in a base class may be overridden in a derived class.
Ex: function tick( ) is redefined in AlarmClock
2. Overloading of operators
The operator + can be used to add pairs of any of the primitive types
and to concatenate Strings. However, Java does not permit the
programmer to define additional operations for any operator.
 The Object-oriented Programming Paradigm
Polymorphism

3. Polymorphic variables

Run-time binding of a method call to a recipient object.

Consider the following application
public class Example {
private Dog fido;
private Bird robin;
public static void main(String [ ] args) {
fido = new Dog( “ -- ruff-ruff”); Make Animal reference to a
robin = new Bird( “ -- tweet-tweet”); derived class object
Animal critter;
critter = fido;
Dog – ruff-ruff Executes method
critter.speak( );
speak( ) for a derived
critter = robin; class object.
critter.speak( ); Bird – tweet-tweet
}
}
 The Object-oriented Programming Paradigm

Polymorphism critter.speak(
critter
critter
tweety
Animal
fido ===tweety;
=
new
fido; ); Bird(“
critter;
newDog(“ ruff-ruff”);
tweet-tweet”);
critter.speak( ); tweet-tweet

critter fido critter tweety

Dog Bird

ruff-ruff tweet-tweet

ruff-ruff Animal base

speak( ) class features speak( )

move( ) Not accessible move( )

by messages to
critter
 The Object-oriented Programming Paradigm
Polymorphism

In the previous example, an Animal object reference (critter) could

attach to objects of the derived classes Dog and Bird and send
messages to any of the methods that were common with (have the
same interface – identifier, parameters, and return type) methods
in the base class.

Note! Casting could be used to be able to send messages to any of the

derived class methods.

(Bird)critter.move( ); //to obtain -- I fly

 The Object-oriented Programming Paradigm
Review

1. The object-oriented paradigm is a programming methodology that

promotes the efficient design and development of software systems
using reusable components that can be quickly and safely assembled
into larger systems.
2. The basic unit of code is the class which is a template for creating
run-time objects.
3. A class encapsulates data (primitive types and object references) and
the operations that can be performed on this data.
4. The modifiers public, private, and protected (accessible to derived
classes, but not to any other) limit and control the access that client
code has to the attributes (data) of a class. Provides for security.
5. Classes can be composed from other classes. For example, Clocks
can be constructed as an aggregate of Counters.
 The Object-oriented Programming Paradigm
Review (cont.)

6. Inheritance provides a means of easily implementing the “is a”

association between classes of objects. A dog “is a(n)” Animal with
additional attributes and behaviors unique to dogs.
7. Much of the power of inheritance derives from the late (run-time)
binding feature of an object-oriented language. We may have a container
of Shapes where the individual Shape objects are instances of derived
classes such as Circle, Square, Rectangle, and Triangle. A reference to a
Shape, will be to one of these derived objects, and a message for the
Shape object to calculate its area will be received by the area( ) method
of the particular derived class object.
8. For container classes to be generally reusable, they must be generic –
able to hold almost any kind of primitive type or object.
9. Java provides automatic garbage collection, relieving the programmer of
the need to ensure that unreferenced memory is regularly deallocated.