Vehicle Garage —
Master Inheritance
Through a Real Project.

Why Inheritance Matters

Inheritance is one of the most powerful tools in object-oriented programming. It enables:

• ✓ Code Reuse: Write shared logic once in a parent class, and all subclasses inherit it automatically.
• ✓ Extensibility: Add new subclasses without modifying existing, tested code — following the Open/Closed Principle.
• ✓ Polymorphism: Write code that works with any object that conforms to a shared interface.
• ✓ Natural Modeling: Class hierarchies mirror real-world relationships — a Dog is an Animal, a Truck is a Vehicle.

Why Every Programmer Should Learn Inheritance

Inheritance is not an optional feature — it is a fundamental paradigm that shapes how software is designed, maintained, and scaled. Here's why you cannot afford to ignore it.

Significance in the Programming Community

The programming community has built entire ecosystems around inheritance. Here's how it shapes the industry:

• 🏗️ Framework Architecture: Every major Python framework uses inheritance to provide "hooks" where developers can plug in custom behavior. Django's class-based views, PyTorch's neural network modules, Flask's request handlers — all built on inheritance.
• 🧩 Mixins and Multiple Inheritance: Python's unique support for multiple inheritance has spawned the "mixin" pattern — small, composable classes that add specific behaviors. This pattern is used extensively in Django, SQLAlchemy, and other libraries.
• 📚 Educational Standard: Inheritance is taught in every introductory programming course, CS curriculum, and bootcamp. It's part of the shared vocabulary that every developer needs to communicate effectively.
• 🤖 AI/ML Ecosystem: The AI community uses inheritance extensively. nn.Module in PyTorch and keras.Model in TensorFlow are both parent classes that you inherit from to build custom architectures.

Step 1: The Parent Class — Vehicle

Every vehicle needs a brand, a license plate, a mileage tracker, and a service log. These are universal — they belong to the parent. This is the foundation of our hierarchy.

class Vehicle:
    def __init__(self, brand: str, plate: str):
        self.brand = brand
        self.plate = plate
        self.mileage = 0
        self.log = []

    def drive(self, miles: int) -> None:
        self.mileage += miles
        self.log.append(f"Driven {miles} miles")

    def service(self) -> str:
        entry = f"Serviced at {self.mileage} miles"
        self.log.append(entry)
        return entry

    def action(self) -> str:
        return f"{self.brand} is just sitting in the garage."

    def info(self) -> str:
        return f"{self.brand} ({self.plate}) — {self.mileage} mi, {len(self.log)} services"

Step 2: Simple Subclassing — Car and Motorcycle

A Car is a Vehicle — it inherits everything. The only thing it changes is the action() method, overriding it with a honk. This is the most common form of inheritance: extending the parent with specialized behavior.

class Car(Vehicle):
    def action(self) -> str:
        return f"{self.brand} honks: Beep beep!"

class Motorcycle(Vehicle):
    def action(self) -> str:
        return f"{self.brand} pops a wheelie!"

my_car = Car("Tesla", "EV-2024")
my_car.drive(50)
print(my_car.info())
print(my_car.action())

Step 3: Extending __init__ — Truck

Trucks need an extra attribute: cargo capacity. This requires overriding __init__ and using super() to call the parent constructor. This is one of the most important patterns in inheritance.

class Truck(Vehicle):
    def __init__(self, brand: str, plate: str, cargo_capacity: int):
        super().__init__(brand, plate)
        self.cargo_capacity = cargo_capacity

    def action(self) -> str:
        return f"{self.brand} hauls up to {self.cargo_capacity}kg of cargo."

truck = Truck("Volvo", "TRK-777", 1500)
print(truck.info())
print(truck.action())

Step 4: Method Overriding in Depth

When a subclass defines a method with the same name as a parent method, it overrides the parent's version. But sometimes you want to extend — not replace — the parent's behavior.

class ElectricCar(Car):
    def __init__(self, brand: str, plate: str, battery_capacity: int):
        super().__init__(brand, plate)
        self.battery_capacity = battery_capacity

    def action(self) -> str:
        base_action = super().action()
        return f"{base_action} And it's electric with {self.battery_capacity}kWh battery!"

    def charge(self) -> str:
        return f"{self.brand} is charging ⚡"

tesla = ElectricCar("Tesla", "EV-2024", 75)
print(tesla.action())
print(tesla.charge())

Step 5: The Complete Hierarchy in Action

Here's the entire hierarchy working together. Run this to see how inheritance enables polymorphism — the loop treats every vehicle uniformly, yet each one behaves correctly.

fleet = [
    Car("Toyota", "ABC-1234"),
    Motorcycle("Ducati", "MC-5521"),
    Truck("Ford", "TRK-9090", cargo_capacity=2000),
    ElectricCar("Tesla", "EV-2024", battery_capacity=75),
]

for v in fleet:
    v.drive(100)
    print(v.info())
    print(" → ", v.action())
    print(" → ", v.service())
    print("---")

Why super() Matters

super() is Python's way of calling a method from the parent class. It's essential for extending parent behavior without duplicating code, and it's the foundation of cooperative multiple inheritance.

class Child(Parent):
    def __init__(self, parent_arg, child_arg):
        super().__init__(parent_arg)
        self.child_arg = child_arg

    def method(self):
        result = super().method()
        return result + " and child's addition"

One Interface, Many Behaviors

Polymorphism lets you write code that works with any object that conforms to a shared interface. In our vehicle hierarchy, that interface is defined by Vehicle.

def garage_report(vehicles):
    for v in vehicles:
        print(v.info())
        print("  → ", v.action())

garage_report([
    Car("BMW", "BMW-123"),
    Motorcycle("Harley", "MC-883"),
    Truck("Scania", "SC-456", 1800),
    ElectricCar("Rivian", "EV-555", 105),
])

Template Method Pattern

The Template Method pattern defines the skeleton of an algorithm in a parent method, letting subclasses override specific steps without changing the algorithm's structure.

class Vehicle:
    def maintenance_checklist(self) -> list:
        checks = ["Check tires", "Check brakes"]
        checks.extend(self._specific_checks())
        return checks

    def _specific_checks(self) -> list:
        return []

class Car(Vehicle):
    def _specific_checks(self) -> list:
        return ["Check engine oil", "Check transmission fluid"]

class Truck(Vehicle):
    def _specific_checks(self) -> list:
        return ["Check air brakes", "Check load securing", "Check hydraulic systems"]

print(Car("Toyota", "ABC-123").maintenance_checklist())
print(Truck("Ford", "TRK-777", 2000).maintenance_checklist())

Inheritance vs Composition

Knowing when to inherit vs when to compose is one of the most important skills in OOP design.

Mixin Pattern

Mixins are small, reusable classes that provide specific functionality to be inherited by other classes. They're designed to be used with multiple inheritance.

class JSONMixin:
    def to_json(self) -> str:
        import json
        return json.dumps(self.to_dict())

class CSVMixin:
    def to_csv(self) -> str:
        return ",".join(self.to_dict().values())

class Vehicle(JSONMixin, CSVMixin):
    def to_dict(self) -> dict:
        return {"brand": self.brand, "plate": self.plate, "mileage": self.mileage}

v = Vehicle("Toyota", "ABC-123")
print(v.to_json())
print(v.to_csv())

Final Words

Inheritance is not just a programming feature — it's a way of thinking about software design. It teaches you to see patterns, recognize shared behavior, and build systems that grow gracefully. Every major Python framework, every design pattern, every well-structured codebase relies on inheritance in some form.

The vehicle hierarchy you built in this tutorial is a microcosm of how real systems work. Django models inherit from models.Model. PyTorch layers inherit from nn.Module. Flask views inherit from View. The pattern is everywhere — and now you understand it.