Computer Science 1001
Lecture 23
Lecture Outline
• Inheritance and Polymorphism
– CS1001 Lecture 23 –
Example: revised Circle class
import math
class Circle:
def __init__(self, x = 0, y = 0, radius = 0):
self.__x = x
self.__y = y
self.__radius = radius
def getX(self):
return self.__x
def getY(self):
return self.__y
def getRadius(self):
return self.__radius
def setX(self, x):
self.__x = x
def setY(self, y):
self.__y = y
def setRadius(self, radius):
self.__radius = radius
def getPerimeter(self):
return 2 * self.__radius * math.pi
def getArea(self):
– CS1001 Lecture 23 – 1
return self.__radius * self.__radius * math.pi
def containsPoint(self, x, y):
d = distance(x, y, self.__x, self.__y)
return d <= self.__radius
def contains(self, circle):
d = distance(self.__x, self.__y, circle.__x, circle.__y)
return d + circle.__radius <= self.__radius
def overlaps(self, circle):
return distance(self.__x, self.__y, circle.__x, circle.__y) \
<= self.__radius + circle.__radius
def __contains__(self, anotherCircle):
return self.contains(anotherCircle)
def __lt__(self, secondCircle):
return self.cmp(secondCircle) < 0
def __le__(self, secondCircle):
return self.cmp(secondCircle) <= 0
def __gt__(self, secondCircle):
return self.cmp(secondCircle) > 0
def __ge__(self, secondCircle):
return self.cmp(secondCircle) >= 0
# Compare two numbers
def cmp(self, secondCircle):
if self.__radius > secondCircle.__radius:
– CS1001 Lecture 23 – 2
return 1
elif self.__radius < secondCircle.__radius:
return -1
else:
return 0
def distance(x1, y1, x2, y2):
return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
– CS1001 Lecture 23 – 3
Using the Circle class
x1 = float(input("Enter x1: "))
y1 = float(input("Enter y1: "))
radius1 = float(input("Enter radius1: "))
x2 = float(input("Enter x2: "))
y2 = float(input("Enter y2: "))
radius2 = float(input("Enter radius2: "))
c1 = Circle(x1, y1, radius1)
c2 = Circle(x2, y2, radius2)
print("Area for c1 is", c1.getArea())
print("Perimeter for c1 is", c1.getPerimeter())
print("Area for c2 is", c2.getArea())
print("Perimeter for c2 is", c2.getPerimeter())
print("c1 contains the center of c2?",
c1.containsPoint(c2.getX(), c2.getY()))
print("c1 contains c2?", c1.contains(c2))
print("c2 in c1?", c2 in c1)
print("c1 overlaps c2?", c1.overlaps(c2))
print("c1 < c2?", c1 < c2)
Sample output:
Enter x1: 3
Enter y1: 5
Enter radius1: 2
Enter x2: 8
Enter y2: 7
Enter radius2: 3
Area for c1 is 12.566370614359172
Perimeter for c1 is 12.566370614359172
– CS1001 Lecture 23 – 4
Area for c2 is 28.274333882308138
Perimeter for c2 is 18.84955592153876
c1 contains the center of c2? False
c1 contains c2? False
c2 in c1? False
c1 overlaps c2? False
c1 < c2? True
– CS1001 Lecture 23 – 5
Inheritance
• Object-oriented programming languages allow us to
define new classes from existing classes.
• This is called inheritance.
• We are defining subclasses from superclasses.
• Subclasses extend superclasses.
• Superclasses are also known as base classes or parent
classes.
• Subclasses are also known as derived classes or child
classes.
– CS1001 Lecture 23 – 6
Inheritance
• Inheritance allows us to:
– Reuse software
– Avoid redundancy
– Facilitate maintenance
– Represent relationships between classes
• A superclass should have properties and behaviours
that are common to other different classes.
• A subclass inherits all accessible data fields and
methods from its superclasses and adds other data
fields and methods.
• Consider the concept of a geometric shape.
• There are many types of shapes, but all shapes have
some common properties, for example, color.
– CS1001 Lecture 23 – 7
Inheritance example
GeometricObject
- color: str the color of the object (def: green)
- filled: bool filled or not filled (def: True)
GeometricObject(color: Construct a GeometricObject
str, filled: bool) with specified color and fill
getColor(): str return the color
setColor(color: str): None set the color
isFilled(): bool return the filled attribute
setFilled(filled: bool): None set the filled attribute
__str__(): str return a string representation
Rectangle
Circle - : float
- radius: float - float
Circle(radius: float, color: R :
str, filled: bool) float, color: str : ,
getRadius(): float g : float
setRadius(radius: float): None sg float): None
getArea(): float float
getPerimeter(): float s float): None
getDiameter(): float getArea(): float
printCircle(): None getPerimeter(): float
– CS1001 Lecture 23 – 8
Example: geometric objects
We could define a GeometricObject as:
class GeometricObject:
def __init__(self, color="green", filled=True):
self.__color = color
self.__filled = filled
def getColor(self):
return self.__color
def setColor(self, color):
self.__color = color
def isFilled(self):
return self.__filled
def setFilled(self, filled):
self.__filled = filled
def __str__(self):
return "color: " + self.__color + \
" and filled: " + str(self.__filled)
– CS1001 Lecture 23 – 9
Defining inheritance
• To define a subclass we include the name of the
superclass as in:
class subClassName(superClassName):
• For example,
class Circle(GeometricObject):
• To refer to the superclass inside a subclass, use
super().
• For example, to invoke the __init__() method
of the superclass within the subclass, use
super().__init__().
– CS1001 Lecture 23 – 10
Example: geometric objects
We could then define specific types of shapes (for
example, Circle) that derive from GeometricObject:
class Circle(GeometricObject):
def __init__(self, radius, color="red", filled=True):
super().__init__(color,filled)
self.__radius = radius
def getRadius(self):
return self.__radius
def setRadius(self, radius):
self.__radius = radius
def getArea(self):
return math.pi*self.__radius**2
def getDiameter(self):
return 2*self.__radius
def getPerimeter(self):
return 2*math.pi*self.__radius
def printCircle(self):
print(self.__str__() + " radius: " + str(self.__radius))
– CS1001 Lecture 23 – 11
Example: geometric objects
We could also define a Rectangle as:
class Rectangle(GeometricObject):
def __init__(self, width=1, height=1, color="blue", filled=True):
super().__init__(color,filled)
self.__width = width
self.__height = height
def getWidth(self):
return self.__width
def getHeight(self):
return self.__height
def setWidth(self,width):
self.__width = width
def setHeight(self,height):
self.__height = height
def getArea(self):
return self.__width*self.__height
def getPerimeter(self):
return 2*(self.__width+self.__height)
– CS1001 Lecture 23 – 12
Example: geometric objects
• Circle and Rectangle inherit all of the methods
in GeometricObject.
• We need to call super().__init__() to create
the data fields defined in the superclass.
• Note that super().__color cannot be accessed
directly. We call super().setColor() to set the
color attribute.
• Calling self.__str__() within printCircle()
invokes the __str__() method in GeometricObject.
• Circle extends the GeometricObject class with a new
data field radius and several instance methods.
– CS1001 Lecture 23 – 13
Example: geometric objects
circle = Circle(1.5)
print("A circle", circle)
print("The radius is", circle.getRadius())
print("The area is", circle.getArea())
print("The diameter is", circle.getDiameter())
print("The color is", circle.getColor())
print("The circle is"," not" if not circle.isFilled() else "",
" filled",sep="")
circle.printCircle()
rectangle = Rectangle(2,4,filled=False)
print("\nA rectangle", rectangle)
print("The area is", rectangle.getArea())
print("The perimeter is", rectangle.getPerimeter())
print("The color is", rectangle.getColor())
print("The rectangle is"," not" if not rectangle.isFilled() else "",
" filled",sep="")
Output:
A circle color: red and filled: True
The radius is 1.5
The area is 7.0685834705770345
The diameter is 3.0
The color is red
The circle is filled
color: red and filled: True radius: 1.5
– CS1001 Lecture 23 – 14
A rectangle color: blue and filled: False
The area is 8
The perimeter is 12
The color is blue
The rectangle is not filled
– CS1001 Lecture 23 – 15
