Abstraction Polymorphism pt 1 Abstracting Objects Polymorphism Polymorphism

Abstraction: Polymorphism, pt. 1 Abstracting Objects

Polymorphism • Polymorphism is one of the central ideas of object-orientation (OO) – that a single object may take on multiple different roles within a program. • It is closely related to inheritance in class hierarchies.

Polymorphism • The word originates from Greek, meaning "having multiple forms. ” – “poly”: many – “morph”: forms

Polymorphism • Some roles treat the object as it relates to its information content and true conceptual purpose within the program. (derived class) • Other roles may exist as an extreme abstraction of its true purpose, extracting a single aspect of the “true” object to allow abstracted methods to utilize it. (base class)

Ideal Program Division Control, UI Data Algorithms

Polymorphism • There are times when we do not need all the specific details of object, but merely a few pieces. – For sorting, we merely need a way to determine the ordering of two same-type objects – we could care less if they are ints or strings, for example. – A… “least common denominator”, if you will, among many types. – Recall templates and generic programming

Polymorphism • In order to facilitate this, a programmer may create custom types for the sole purpose of representing each such role. – In Java, these are called interfaces. – Each such custom type declares a set of methods necessary to fulfill the functionalities of that role. • For the last slide’s example, we would need a comparison method.

Polymorphism • The idea is that each such custom type provides the minimum specification and blueprint necessary for performing that role. – This custom type is then implemented by classes in order to perform the represented role.

Polymorphism • Since the specification and method names are declared in the custom type, those methods can be accessed through the custom type, without needing more specific type information. • The actual implementation is left to each implementing (specific) class.

Polymorphism in C++ • For a starter example, let’s suppose we want to use polymorphism to calculate geometrical properties of shapes. – The user first specifies a shape, with its relevant parameters. – Afterward, the user may ask for its properties derived from its parameters, or for actions to be performed on it.

Polymorphism in C++ • Take a couple of minutes and team up to discuss shapes, parameters, properties, and actions. – What are some shapes? • Circle, square, triangle, … – What parameters do they have? • Edge thickness and color, fill color, … – What properties do they have? • perimeter length, area, … – What actions may be performed? • for it to be drawn, …

Polymorphism in C++ • We note that perimeter length and area are common properties of any shape. • Shapes also commonly have visual forms. • Thus, these are all reasonable properties for a common “Shape” role to have within our program.

Polymorphism in C++ class Shape { public: virtual double area() = 0; virtual double perimeter() = 0; } • The “= 0” on each method indicates that our class Shape does not define the method – it is the responsibility of any class fulfilling this role to implement them instead.

Polymorphism in C++ class Shape { public: virtual double area() = 0; virtual double perimeter() = 0; } • The keyword “virtual” on the methods indicates that Shape expects implementing classes to provide their own definition, and will allow those to be accessed from the Shape perspective.

Polymorphism in C++ • Note: because the area() and perimeter() methods have no implementation within Shape, it is not possible to create an instance of Shape directly. • Instead, the point is to have other classes implement the Shape role and to be able to use them from that perspective.

Polymorphism in C++ class Circle: public Shape { public: Circle(double r); double area(); double perimeter(); void draw(); private: double radius; }

Polymorphism in C++ double Circle: : area() { // Assuming a predefined PI constant. return PI * radius; } Circle: : Circle(double r) { radius = r; } /* Implementation of the other methods left to the imagination. */

Polymorphism in C++ class Circle: public Shape { public: Note the phrasingr); here – the colon Circle(double indicates that Circle is inheriting the double area(); specifications and preexisting blueprint of double perimeter(); the typevoid Shape. The “public” keyword says draw(); that we can use Circle objects as if they were Shape objects, with access to the private: virtual functions double radius; declared in Shape. }

Exercise 1 • Create class declarations for Shape and Square – omit draw() • Create method definitions for Square • Create a small main() to create a few squares of various sides, then output their areas and perimeters. • Compile and run

Exercise 2 • Now in your main(), create an object that is just a Shape, not a Square. • Compile • What is (are) the error message(s)?

Polymorphism in C++ • If a class does not provide an implementation of a “pure” virtual method, it is impossible to directly instantiate that class. – This includes cases where an object does not define a virtual method declared in its parent class, as would happen if we left area() undefined within our Circle class.

Polymorphism • Polymorphism allows the programmer to provide alternate, abstracted views of an object. – These “views” will limit access to class fields and methods, exposing only those defined as part of that “view. ” – In a manner of speaking, the type Shape exists to provide a restricted “view” of Circle.

Class Hierarchy • Another way to look at it is that the classes form a hierarchy, with the base class capturing the fundamental qualities the classes have in common – Classes in the tree under the base class may be described in terms of the base class • Derived classes then inherit the qualities of the base class whence they are derived, and perhaps add to or tweak it – Subclass functions override those of their superclass

Polymorphism • Polymorphism allows the programmer to provide alternate, abstracted views of an object. – While this isn’t useful if all we have is Circle, the reasoning becomes more important with Square, Pentagon, and Hexagon (for example). – Squares aren’t Circles, but they are both Shapes, with Shape properties.

Polymorphism • All of the following are legal code lines, assuming good class definitions. Shape* s 1 = new Circle(4); Shape* s 2 = new Square(4); Shape* s 3 = new Pentagon(4);

Polymorphism • Suppose, then, that we have vector<Shape*> shape. List, and want to sum up the area of all the stored, referenced Shapes. double area. Sum = 0; for(int i=0; i < shape. List. size(); i++) area. Sum += shape. List[i]->area();

Polymorphism • This is but one example of polymorphism. • Others: – Human and Computer in interactive games – “Tools” in photo-editing software can be implemented this way – Quotes in example in book

Questions?

C++ Practicalities • Note how we’re storing each Shape via reference. – This is because in creating a by-value variable of Shape, it is attached directly to an inherent Shape instance. • For one, this is impossible to instantiate, as Shape has pure virtual methods. • Secondly, that instance would be of exactly type Shape – attempting assignment would be on an implied Shape: : operator=().

C++ Practicalities • Note how we’re storing each Shape via pointer – Use of polymorphism in C++ requires handling objects via their pointers • A pointer of a subclass can always be stored as a variable of its superclass • Technically, through polymorphism, a pointer of a subclass is a pointer to an instance of the superclass – just with further specification.

A Quick Note • At this point in the class, we will not be examining full “inheritance. ” – Understanding and being able to use polymorphism is a large enough issue in and of itself at this time. – The main difference: full inheritance allows for pre-defined methods and fields; actual functionality is, well, inherited.

A Quick Note • While our present example used only virtual, undefined methods in the base type (Shape), this is not a strict requirement of C++; more can be inherited. – Our present aim is to understand the design goals behind polymorphism… which also affects inheritance in C++.

Polymorphism • Polymorphism allows for multiple classes to share similar abstract views that may be seen as a single “role”. – Very distinct, different types sometimes share functionally similar methods. – The implementation of these methods may be specific to each implementing class, and is not directly sharable.

Questions?