slide1 l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Polymorphism PowerPoint Presentation
Download Presentation
Polymorphism

Loading in 2 Seconds...

play fullscreen
1 / 22

Polymorphism - PowerPoint PPT Presentation


  • 222 Views
  • Uploaded on

Polymorphism. Contents . Forms of polymorphism Polymorphic variables – late (run-time binding) Abstract classes – example, Shape Inheritance and polymorphism. Polymorphism . Forms of poymorphism. operator overloading.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Polymorphism' - lindley


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

Polymorphism

Contents

  • Forms of polymorphism
  • Polymorphic variables – late (run-time binding)
  • Abstract classes – example, Shape
  • Inheritance and polymorphism
slide2

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

slide3

Shape

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

area()

perimeter()

Rectangle

Circle

area()

perimeter()

area()

perimeter()

The Object-oriented Programming Paradigm

Polymorphic Variables

Circle and Rectangle are concrete classes with their own separate implementations of the methods area() and Perimeter()

slide4

The Object-oriented Programming Paradigm

Abstract Classes

There can be NO instances of an abstract class (no Shape objects)

Concrete realizations of Shape

Abstract Shape class

public abstractclass Shape {

protected String shapeName;

public Shape(String name) {shapeName = name;}

publicabstractdouble area ( );

publicabstractdouble perimeter ( );

public String toString( ) {return shapeName;};

}

Class MUST be qualified as abstract if one or more methods are abstract

public class Circle extends Shape {

private double radius;

public Circle (double rad) {

super (“Circle”);

radius = rad;

}

publicdouble area( ) {

return Math.PI * radius * radius; }

public double perimeter( ) {

return 2.0 * Math.PI * radius; }

}

public class Rectangle extends Shape{

protecteddouble length, width;

public Rectangle(double len, double wid) {

super(“Rectangle”);

length = len; width = wid;

}

publicdouble area ( ) {return length * width;}

publicdouble perimeter ( ) {

return 2.0 * (length + width); }

}

slide5

Shape

Attributes inherited from Rectangle

Circle

Rectangle

Square

The Object-oriented Programming Paradigm

Square extends Rectangle

Additional inheritance

public class Square extends Rectangle {

public Square (double side) {

super (“Square”);

length = width = side;

}

}

BUT! There is a problem!

super(“Square”); refers to the base class of Square – which is Rectangle.

We need to add a constructor:

Rectangle(String name) {

super(name);

}

to class Rectangle -- to “pass the string Square” up to the base class.

Add a class Square to the collection of shapes.

slide6

The Object-oriented Programming Paradigm

A vector of Shapes

A container of Shape objects will execute their own area and perimeter methods

slide7

Create an array to hold objects of (derived from) class Shape

Create objects of the derived classes and put them in shapeList

The Object-oriented Programming Paradigm

Example (an array of Shapes)

publicclass ShapeShifter {

publicstaticvoid main (String [ ] args) {

Shape [ ] shapeList = new Shape[5];

shapeList[0] = new Circle(3.0);

shapeList[1] = new Rectangle(3.0, 4.0);

shapeList[2] = new Rectangle(2.5, 7.5);

shapeList[3] = new Circle(2.5);

shapeList[4] = new Square(5.0);

for (int i = 0; i < shapeList.length; i++) {

System.out.print (shapeList[i].toString( ) + “ ” );

System.out.print (shapeList[i].area( ) + “ ”);

System.out.println (shapeList[i].perimeter( ));

}

}

}

Iterate through the list and show area and perimeter of shapes

Each derived class object executes its own area and perimeter methods

slide8

Animal

private String name;

private String says;

The Object-oriented Programming Paradigm

Inheritance

Consider a class Animal:

Attributes

Constructor

public Animal(String str, String s2){

name = new String(str);

says = new String(s2);

}

Behavior

public void speak( ) {

System.out.println(name+says);

}

slide9

The Object-oriented Programming Paradigm

Inheritance

Animal serves as the base class for several derived classes

publicclass Dog extends Animal {

public Dog(String says ) {

super(“Dog”, says);

}

publicvoid move ( ) {

System.out.println(“ -- I run”);

}

}

publicclass Bird extends Animal {

public Bird(String says) {

super(“Bird”,says);

}

publicvoid move ( ) {

System.out.println(“ -- I fly”);

}

Initialize base class attributes

New methods can extend the behavior of the base class

slide10

Animal

String name;

String says;

public Animal(String, String)

publicvoid speak( )

Dog

Bird

public Dog(String)

publicvoid move( )

public Bird(String)

public void move( )

The Object-oriented Programming Paradigm

Inheritance

Base class

Derived classes extend the base class

slide11

The Object-oriented Programming Paradigm

Inheritance

Consider the following application (class AnimalHouse)

publicclass AnimalHouse {

private Dog Lassie;

private Bird TweetyBird;

private Animal Felix;

public AnimalHouse ( ) {

Lassie = new Dog(“ -- bow-wow”);

TweetyBird = new Bird(“ -- tweet-tweet”);

Felix = new Animal(“Cat”, “ – meoow”);

}

publicvoid animalAct( ) {

Lassie.speak( );

TweetyBird.speak( );

Felix.speak( );

Lassie.move( );

TweetyBird.move( );

}

publicstaticvoid main(String [ ] args) {

AnimalHouse zoo = new AnimalHouse( );

zoo.animalAct( );

}

}//end class AnimalHouse

Output

The class contains three attributes (“data” members) that are objects of the base class Animal, or one of the classes derived from it.

The constructor allocates memory for the three private objects and initializes their attributes.

The application class (AnimalHouse) contains a main function that creates an instance of the class and tells the AnimalHouse object zoo to execute its animalAct( ) operation.

Dog -- bow-wow

Bird -- tweet-tweet

Cat -- meoow

-- I run

-- I fly

Felix cannot receive a message move( )

slide12

The Object-oriented Programming Paradigm

Composition

Consider the class Counter described below

publicclass Counter {

privateint count, base;

public Counter(int baseVal) {…}

publicvoid increment( ) {…}

publicvoid reset( ) {…}

publicint viewCount( ) {…}

}

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

slide13

These Counter objects are not accessible outside of a Clock object.

Each Clock object must hold its own set of Counter objects

The Object-oriented Programming Paradigm

Composition

publicclass Clock {

private Counter hours, mins, secs;

public Clock( )

hours = new Counter(24);

mins = new Counter(60);

secs = new Counter(60);

}

publicvoid tick( ) {

secs.increment( );

if (secs.viewCount( ) == 0) {

mins.increment( );

if((secs.viewCount( )==0) && (mins.viewCount( ) == 0))

hours.increment( );

}

}

}

Clock methods are implemented by the Counter components

In an assignment you will add methods set( ) and viewHr(), viewMin( ), and viewSec( ) to this class

slide14

Inherits from class Clock

Additional attributes in an AlarmClock

Override the implementation of tick( ) in parent

Execute the version of this method in the parent 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.

publicclass AlarmClock extends Clock {

privateboolean alarmOn;

privateint hrSet, minSet;

public AlarmClock( ) {alarmOn = false;} //the alarm is not set initially

publicvoid setAlarm(int hr, int min) {

hrSet = hr; minSet = min; alarmOn = true;

}

publicvoid tick( ) {

super.tick( );

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

System.out.println(“ring, ring, ring”);

}

publicvoid resetAlarm( ) {alarmOn = false;}

}

Additional methods in AlarmClock

viewHr() and viewMin( ) are methods in an AlarmClock that are inherited from its parent

slide15

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

slide16

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.

slide17

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: publicstaticint sqr(int x) {…}

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

slide18

Make Animal reference to a derived class object

Dog – ruff-ruff

Bird – tweet-tweet

The Object-oriented Programming Paradigm

Polymorphism

3. Polymorphic variables

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

Consider the following application

publicclass Example {

private Dog fido;

private Bird robin;

publicstaticvoid main(String [ ] args) {

fido = new Dog( “ -- ruff-ruff”);

robin = new Bird( “ -- tweet-tweet”);

Animal critter;

critter = fido;

critter.speak( );

critter = robin;

critter.speak( );

}

}

Executes method speak( ) for a derived class object.

slide19

fido

tweety

critter

critter

Dog

Bird

ruff-ruff

tweet-tweet

speak( )

speak( )

move( )

move( )

The Object-oriented Programming Paradigm

critter.speak( );

Polymorphism

critter = tweety;

critter = fido;

tweety = new Bird(“ tweet-tweet”);

Animal critter;

fido = new Dog(“ ruff-ruff”);

critter.speak( );

tweet-tweet

ruff-ruff

Animal base class features

Not accessible by messages to critter

slide20

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

slide21

The Object-oriented Programming Paradigm

Review

  • 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.
  • The basic unit of code is the class which is a template for creating run-time objects.
  • A class encapsulates data (primitive types and object references) and the operations that can be performed on this data.
  • 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.
  • Classes can be composed from other classes. For example, Clocks can be constructed as an aggregate of Counters.
slide22

The Object-oriented Programming Paradigm

Review (cont.)

  • 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.
  • 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.
  • For container classes to be generally reusable, they must be generic – able to hold almost any kind of primitive type or object.
  • Java provides automatic garbage collection, relieving the programmer of the need to ensure that unreferenced memory is regularly deallocated.