Single Inheritance

The Company Org Chart

Every company has a hierarchy. At the top sits the CEO — responsible for strategy, stakeholder relations, and overall company direction. Below the CEO is the CTO, who inherits all those general leadership responsibilities and adds specific technical ones: overseeing the engineering teams, choosing the tech stack, driving architectural decisions.

Further down is the Software Engineer, who inherits from the technical leadership role: they still attend meetings, still communicate with stakeholders at some level — but their day-to-day is writing and reviewing code.

Each level in the chart inherits from the one above it. Nobody re-defines what "showing up to work" means at every level — they inherit it and, where needed, extend or override it.

That is exactly how inheritance works in OOP.

Why Inheritance?

Imagine building a fleet of vehicles without inheritance:

class Car:
    def start(self): print("Car starts")
    def stop(self):  print("Car stops")
    def honk(self):  print("Beep!")

class Truck:
    def start(self): print("Truck starts")  # Copy-paste
    def stop(self):  print("Truck stops")   # Copy-paste
    def honk(self):  print("HOOOONK!")

Every shared behaviour is duplicated. Fix a bug in start() and you must fix it in every class. Inheritance solves this by putting shared behaviour in one place.

Basic Syntax

class Parent:
    pass

class Child(Parent):    # Child inherits from Parent
    pass

The child class gains everything the parent defined — all attributes, all methods — automatically.

A Three-Level Chain: Vehicle → Car → ElectricCar

# Level 1 — the base class
class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def start(self):
        print(f"{self.make} {self.model} engine starting...")

    def stop(self):
        print(f"{self.make} {self.model} stopping.")

    def __str__(self):
        return f"{self.year} {self.make} {self.model}"

# Level 2 — Car inherits from Vehicle
class Car(Vehicle):
    def __init__(self, make, model, year, num_doors):
        super().__init__(make, model, year)  # Call parent's __init__
        self.num_doors = num_doors           # Add Car-specific data

    def honk(self):
        print("Beep beep!")

    def __str__(self):
        # Extend parent's __str__ rather than replace it entirely
        base = super().__str__()
        return f"{base} ({self.num_doors}-door)"

# Level 3 — ElectricCar inherits from Car
class ElectricCar(Car):
    def __init__(self, make, model, year, num_doors, battery_kwh):
        super().__init__(make, model, year, num_doors)  # Call Car's __init__
        self.battery_kwh = battery_kwh                  # Add EV-specific data

    def start(self):
        # OVERRIDE Vehicle's start — EV doesn't have an engine noise
        print(f"{self.make} {self.model} silently powering up...")

    def charge(self):
        print(f"Charging {self.battery_kwh} kWh battery.")

    def __str__(self):
        base = super().__str__()
        return f"{base} [EV, {self.battery_kwh} kWh]"

Running the Chain

# Create objects at each level
van = Vehicle("Ford", "Transit", 2020)
sedan = Car("Honda", "Accord", 2022, 4)
ev = ElectricCar("Tesla", "Model S", 2024, 4, 100)

# Vehicle behaviour
van.start()
van.stop()
print(van)

print("---")

# Car inherits start/stop, adds honk
sedan.start()
sedan.honk()
print(sedan)

print("---")

# ElectricCar OVERRIDES start, inherits stop and honk
ev.start()
ev.stop()
ev.honk()
ev.charge()
print(ev)

Output:

Ford Transit engine starting...
Ford Transit stopping.
2020 Ford Transit
---
Honda Accord engine starting...
Beep beep!
2022 Honda Accord (4-door)
---
Tesla Model S silently powering up...
Tesla Model S stopping.
Beep beep!
Charging 100 kWh battery.
2024 Tesla Model S (4-door) [EV, 100 kWh]

What Is Inherited?

When ElectricCar extends Car which extends Vehicle:

• ElectricCar can call stop() — defined on Vehicle, inherited through Car.
• ElectricCar can call honk() — defined on Car, inherited directly.
• ElectricCar overrides start() — it defines its own version, which shadows the one on Vehicle.

You can verify the full chain with isinstance():

print(isinstance(ev, ElectricCar))  # True
print(isinstance(ev, Car))          # True
print(isinstance(ev, Vehicle))      # True

The super() Function

super() is how you call the parent class's version of a method. It is most critical in __init__:

class Car(Vehicle):
    def __init__(self, make, model, year, num_doors):
        super().__init__(make, model, year)  # Run Vehicle's __init__ first
        self.num_doors = num_doors           # Then add Car's own setup

Without super().__init__(...):

• self.make, self.model, and self.year would never be set.
• Every method that references those attributes would crash.

Always call super().__init__() in a child class unless you have a specific reason not to.

Overriding Parent Methods

Overriding is simply defining a method in the child with the same name as one in the parent. The child's version takes precedence for that class.

You have three choices when overriding:

1. Full replacement — write a completely new body, don't call super().
2. Extension — call super().method() first (or last), then add new behaviour.
3. Selective — call super().method() only under certain conditions.

class ElectricCar(Car):
    def start(self):
        # Full replacement — EV behaviour is completely different
        print(f"{self.make} {self.model} silently powering up...")

When NOT to Use Inheritance

Inheritance creates tight coupling — if the parent class changes, every child class may break. Prefer inheritance only when the relationship is genuinely "is-a":

"Favour composition over inheritance" is one of the classic principles of OOP design. Inheritance is powerful — but composition (giving an object a reference to another object) is often more flexible and less fragile.

Key Takeaways

• Inheritance lets a child class reuse all attributes and methods of a parent class.
• Use class Child(Parent): syntax to declare inheritance.
• Always call super().__init__(...) in the child's __init__ to properly initialise the parent portion.
• Override a method by redefining it in the child; use super().method() to extend rather than fully replace.
• Only use inheritance for genuine "is-a" relationships; prefer composition otherwise.