OOP Inheritance

A teacher and a student are both people: they share a name and an age, and both can introduce themselves. Writing that shared code twice is wasteful. Inheritance lets you write the shared parts once in a parent class, then create child classes that automatically get them and add their own extras.

By the end of this page you will define a parent class, build a child class that inherits from it, reuse the parent's constructor with super(), override a method to change its behaviour, and use polymorphism so a single loop can call the same method on a mixed list of objects.

In Python a child class names its parent in brackets: class Car(Vehicle). The child then has every attribute and method of Vehicle for free, and can add its own.

class Vehicle:                       # parent (superclass)
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    def start(self):
        print(self.brand, self.model, "is starting.")

class Car(Vehicle):                  # child inherits Vehicle
    def __init__(self, brand, model, doors):
        super().__init__(brand, model)   # reuse parent constructor
        self.doors = doors
    def honk(self):
        print(self.brand, "goes beep!")

car = Car("Toyota", "Corolla", 4)
car.start()    # inherited from Vehicle
car.honk()     # defined in Car

The pseudocode equivalent uses the keyword INHERITS:

CLASS Vehicle
    PRIVATE Brand : STRING
    PUBLIC PROCEDURE NEW(GivenBrand : STRING)
        Brand <- GivenBrand
    ENDPROCEDURE
ENDCLASS

CLASS Car INHERITS Vehicle
    PRIVATE Model : STRING
    PUBLIC PROCEDURE NEW(GivenBrand : STRING, GivenModel : STRING)
        SUPER.NEW(GivenBrand)
        Model <- GivenModel
    ENDPROCEDURE
ENDCLASS

Inside the child constructor, super().__init__(...) runs the parent constructor first, then the child adds its extra attribute. To override, the child simply defines a method with the same name — its version runs instead of the parent's.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def introduce(self):
        print("I am", self.name)

class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)    # reuse parent constructor
        self.subject = subject
    def introduce(self):               # override
        print("I am", self.name, "and I teach", self.subject)

t = Teacher("Mrs Rahman", 42, "Computer Science")
t.introduce()
# Output: I am Mrs Rahman and I teach Computer Science

Put different objects in one list and loop over them, calling the shared method. Python runs each object's own overridden version automatically.

people = [Teacher("Mrs Rahman", 42, "CS"),
          Student("Rumaisa", 17, 90),
          Student("Aymaan", 17, 78)]

for person in people:
    person.introduce()     # each runs its own version

Fifteen exam-style tasks. Click Hint for bullet-point guidance, then Help to reveal a worked Python solution.