[PDF] Encapsulation + Inheritance + Polymorphism

Inheritance and Polymorphism
CS 355
March 1, 2006
1. Object Oriented Programming (OOP)
2. Inheritance
• Motivation 1: Software reuse
OOP = ADT + inheritance + polymorphism
– Given: An ADT that has 90% of the functionality you want.
– Solution: Create a new ADT that inherits the functionality of the given ADT plus adds the
remaining features.
– Example: Say we are given a ADT Point that encapsulates the notion of a location in 2D.
class Point {
protected:
double x, y;
public:
Point(double xx = 0.0, double yy = 0.0) : x(xx), y(yy) {}
double getx() const {return x;}
double gety() const {return y;}
void move(double x, double y) {this->x = x, this->y = y;}
void moveRel(double x, double y) {this->x += x; this->y += y;}
void draw() const {glBegin(GL_POINTS); glVertex2f(x,y); glEnd();}
};
Say we want to create a Circle ADT that allows us to represent circles centered at various
locations. We can “inherit” the functionality we want from the Point ADT and add the extra
stuff needed to represent a circle.
class Circle : public Point {
protected:
double rad;
public:
Circle(double x = 0.0, double y = 0.0, double r = 1.0) : Point(x,y), rad(r) {}
static const double pi;
double area() const {return pi*rad*rad;}
void draw() const;
};
const double Circle::pi = 3.1415926535;
void Circle::draw() const {
// insert code to draw a circle centered at (x,y) with radius ’rad’
}
1

The Circle class inherited all the fields and methods of the Point class. Therefore we can
create an instance of Circle and invoke all the inherited methods (e.g., move) plus the newly
defined methods (e.g., area) on that instance.
∗ We call Point the superclass or the base class. We call Circle the subclass or the derived
class.
∗ Note that a Circle is a Point, but not vice versa.
∗ Note the new keyword protected. This is synonymous with private for peer classes,
but is like public for derived classes.
∗ Note the new notation for invoking the superclass’s constructor. It is often critical for
all superclasses to be completely initialized before any derived classes! Destructors are
invoked in reverse order (why?).
• Motivation 2: Program organization
– Without inheritance, all ADT’s are independent peer entities which is not always a good fit
for the problem space being addressing.
– With inheritance we can create hierarchies of ADT’s more accurately model the commonality
between different types.
• Overriding behavior
3. Polymorphism
– Not only can we add functionality in a derived class, we can override certain behaviors defined
in the super class. This is accomplished by redefining inherited methods in the derived class.
Note the behavior with regards to the draw method has been overridden by the Circle class.
• Polymorphism (literally “many forms”) means one type can have many forms.
• Example: Polymorphic shapes
– We create a base class Shape that can take on many forms (it can behave like a point, a circle,
or a rectangle).
– A shape is really an abstract concept.
Question: What is the area of a shape?
Answer: It depends on what kind of shape it is.
– The polymorphic methods of Shape are area and draw. In C++ we call these “virtual
methods” and tag them with the keyword virtual.
class Shape {
protected:
int x, y; // location
public:
Shape (int xx = 0, int yy = 0) : x(xx), y(yy) {}
int getx() const {return x;}
int gety() const {return y;}
void move(int x, int y) {this->x = x, this->y = y;}
void moveRel(int x, int y) {this->x += x; this->y += y;}
virtual double area() const = 0;
virtual void draw() const = 0;
};
// pure virtual method (no implementation)
// pure virtual method
2

– Note that the Shape class specifically states that it does not implement the area and draw
methods (the syntax implies that their implementation is null). These type of methods are
called pure virtual methods.
– Classes that contain pure virtual methods can not be instantiated (why?). We call these
Abstract classes.
– The motivation for creating such a class is to isolate all the features that shapes have in
common and define them exactly once! What are the benefits to doing this?
– Here we created a concrete type called Rectangle
class Rectangle : public Shape {
int w, h;
public:
Rectangle(int x = 0, int y = 0, int w = 1, int h = 1) : Shape(x,y) {
this->w = w; this->h = h;
}
virtual double area() const {return w*h;}
virtual void draw() const;
};
void Rectangle::draw() const {
glBegin(GL_LINE_LOOP);
glVertex2i(x, y);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glVertex2i(x, y+h);
glEnd();
}
– Since Rectangle is concrete, we can actually create instances of type Rectangle:
Shape *s = new Rectangle(10, 10, 50, 50); // legal: concrete class
Shape *s = new Shape(10,10); // illegal!! abstract class
– Here we create another concrete class Circle:
class Circle : public Shape {
int radius;
public:
Circle(int x = 0, int y = 0, int rad = 1) : Shape(x,y) {radius = rad;}
static const double pi;
virtual double area() const {return pi*radius*radius;}
virtual void draw() const;
};
const double Circle::pi = 3.1415926;
void Circle::draw() const {
glPushMatrix();
glTranslatef(double(x),double(y),0);
glBegin(GL_LINE_LOOP);
const int numlines = 100;
const double dtheta = 2*pi/numlines;
int i; double theta;
for (i = 0, theta = 0.0; i < numlines; i++, theta += dtheta)
glVertex2d(radius*cos(theta), radius*sin(theta));
glEnd();
glPopMatrix();
}
3

– Since Shape is abstract, we can not create an array of Shape’s, but we can create an an array
of pointers to Shape’s What is the practical reason for this?
const int numshapes = 3;
Shape *shapes[numshapes];
...
shapes[0] = new Rectangle(10, 10, 50, 50);
shapes[1] = new Rectangle(300, 10, 50, 200);
shapes[2] = new Circle(300,300, 100);
...
for (int i = 0; i < numshapes; i++)
shapes[i]->draw();
• These examples demonstrate both interface inheritance, and implementation inheritance.
• Interface inheritence in C++, Objective-C, and Java
– Example: Say we want to insert objects into a priority queue which requires that each object
has a priority() method as defined by the following abstract class:
class Prioritorizable {
public:
virtual int priority() const = 0;
};
The interface for PriorityQueue could look like this:
class PriorityQueue {
...
public:
...
void insert(Prioritorizable *elem);
Prioritorizable *deleteMin();
};
Here we define a concrete subclass of Prioritorizable called Widget:
class Widget : public Prioritorizable {
...
int p;
public:
virtual int priority() const {return p;}
};
Now we can insert instances of Widget into PriorityQueue’s. Say we also want to insert
intances of Widget into a hash table that requires Widget to be a subclass of the abstract
class Hashable:
class Hashable {
public:
virtual long int hash() const = 0;
};
To solve this problem in C++, we must use multiple inheritance by defining Widget to be a
subclass of both Prioritorizable and Hashable:
class Widget : public Prioritorizable, public Hashable {
...
public:
virtual int priority() const { ... }
virtual long int hash() const = { ... }
};
4

This is probably the least objectionable use of multiple inheritence in C++, because we
are simple inheriting mutiple interfaces which is not as troublesome as inheriting multiple
implementations (why might this be problamatic?).
– Objective-C allows only single inheritence, but allows the programmer to define a class that
conforms to mutiple protocols:
@protocol Prioritorizable
-(int) priority;
@end
@protocol Hashable
-(long int) hash;
@end
@interface Widget : NSObject
...
-(int) priority;
-(long int) hash;
@end
Here Widget is a subtype of NSObject, but conforms to the protocols Prioritorizable and
Hashable. At runtime, we can check to see if an object conforms to some particular protocol:
if ([obj conformsTo:@protocol(Hashable)]) ...
– Java also only allows single inheritence, but borrowed Objective-C’s notion of protocol’s. In
Java a protocol is termed interface (not the same as Objective-C’s interfaces):
public interface Prioritorizable {
public int priority();
}
public interface Hashable {
public long int hash();
}
public class Widget extends Object implements Prioritorizable, Hashable {
...
public int priority() { ... }
public long int hash() { ... }
}
4. Virtual Function Tables and Dynamic Dispatch
• Note that when we specified the draw() method in our Shape class we used the keyword virtual.
This specifies that the actual draw() method that is called is not known until runtime:
Shape *shape;
...
shape->draw();
// Which draw method is called?
Non-virtual method calls in C++ are statically linked to the appropriate function body:
shape->move(1, 2);
// Use Shape’s move() method (shape in not virtual)
Polymorphic operators (i.e., virtual methods) are implemented in C++ by using a look-up table
(called a virtual function table) attached to each object that maps method signatures to function
addresses at runtime.
5

• All methods in Java and Objective-C are “virtual.” Objective-C uses a much more sophisticated
technique called dynamic dispatch which we will talk about later.
6