1 / 22

Polymorphism

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

lindley
Download Presentation

Polymorphism

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

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

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

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

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

  6. The Object-oriented Programming Paradigm A vector of Shapes A container of Shape objects will execute their own area and perimeter methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

More Related