🍽️ Inheritance Mastery Lesson 3 of 8

🍕 Restaurant Menu System

Master inheritance through a realistic restaurant menu. Learn to model real-world relationships, override methods, apply the Liskov Substitution Principle, and build polymorphic systems.

Python 3.11+ Hierarchical Inheritance Pricing Overrides Live Code Runner ~60 min In Progress

Start Coding Practice Back to Hub

00 — Learning Objectives

🎯 By the end of this module, you will be able to:

Design a base MenuItem class with shared attributes and methods
Create specialized subclasses: Appetizer, MainCourse, Dessert, Beverage
Override methods like get_price() and prepare() for unique behavior
Use super() correctly to initialize parent classes
Apply polymorphism to build flexible menu systems
Understand the Liskov Substitution Principle (LSP)
Identify when inheritance is (and isn't) the right tool
Contrast inheritance with composition using real examples

📋 Learning Progress

Understand the duplication problem without inheritance

Can design a base MenuItem class

Can create subclasses with super()

Can override methods for specialized behavior

Understand polymorphism and can use it

Can explain the Open/Closed Principle

Understand the Liskov Substitution Principle (LSP)

Can identify when to use composition over inheritance

01 — Core Concepts

The Duplication Problem

Without inheritance, you'd write nearly identical classes for each menu category:

❌

Without Inheritance — Duplicated Code

class Appetizer: def __init__(self, name, price, description, serving_size): self.name = name self.price = price self.description = description self.serving_size = serving_size def get_price(self): return self.price def prepare(self): return "Preparing appetizer..." class MainCourse: Same __init__, same get_price, same structure class Dessert: Same __init__, same get_price, same structure

⚠️ The Problem: The __init__ and get_price() logic is duplicated. If you need to add a new attribute (like calories), you must update it in three places. This violates the DRY (Don't Repeat Yourself) principle.

The Solution: Inheritance

✓

With Inheritance — Clean, DRY Code

class MenuItem: def __init__(self, name, price, description): self.name = name self.price = price self.description = description def get_price(self): return self.price def prepare(self): raise NotImplementedError() class Appetizer(MenuItem): def __init__(self, name, price, description, serving_size): super().__init__(name, price, description) self.serving_size = serving_size def prepare(self): return f"Preparing {self.name}..."

✅ Result: The duplication is gone. All menu items share the same base structure. If you add a new common attribute, you add it once in the base class.

🍽️ MenuItem

• name, price, description

get_price() → price

prepare() [abstract]

display() → formatted string

⬇️ inherits

🍽️ Appetizer

• serving_size

prepare() → plating

🍳 MainCourse

• cooking_time

prepare() → cooking

get_price() → +$2.50

🍰 Dessert

• has_whipped_cream

prepare() → plating

☕ Beverage

• size, is_hot

prepare() → serving

get_price() → size-based

🔑 Key Concept: The Open/Closed Principle

The MenuItem base class is open for extension (you can add new menu categories) but closed for modification (you don't need to change existing code). This is one of the SOLID principles of object-oriented design.

The Liskov Substitution Principle (LSP)

LSP states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

❌ Breaking LSP — Bad Example:

class BrokenMainCourse(MainCourse):
    def get_price(self) -> float:
        if self.cooking_time > 30:
            raise ValueError("This dish takes too long!")
        return super().get_price()
        

If code expects MainCourse and calls get_price(), it will fail unexpectedly for this subclass. This violates LSP.

✅ Following LSP — Good Example:

class GoodMainCourse(MainCourse):
    def get_price(self) -> float:
        if self.cooking_time > 30:
            return super().get_price() + 5.00
        return super().get_price()
        

This subclass extends behavior without breaking the contract. It still returns a float and works wherever MainCourse is expected.

Inheritance vs Composition

A ComboMeal is not a type of MenuItem — it has menu items. This is composition, and it's often the better choice.

Inheritance ("is-a")

"A MainCourse is a MenuItem"

Use for specialization
Changes to parent affect children
Can lead to deep hierarchies

Composition ("has-a")

"A ComboMeal has MenuItem objects"

Use for containment
Changes are isolated
More flexible and testable

💡 When to use which: Use inheritance when you have a clear "is-a" relationship and you want to reuse behavior. Use composition when you have a "has-a" relationship or when you want to avoid tight coupling. In modern Python, many developers prefer composition + protocols over deep inheritance.

02 — Interactive Code

Build the Restaurant Menu

Edit the code below, then click Run to execute it. Click Test to run automated tests on your code.

restaurant_menu.py

class MenuItem:
    def __init__(self, name: str, price: float, description: str):
        self.name = name
        self.price = price
        self.description = description

    def get_price(self) -> float:
        return self.price

    def prepare(self) -> str:
        raise NotImplementedError("Subclasses must implement prepare()")

    def display(self) -> str:
        return f"{self.name}: ${self.price:.2f} - {self.description}"

class Appetizer(MenuItem):
    def __init__(self, name: str, price: float, description: str, serving_size: str = "small"):
        super().__init__(name, price, description)
        self.serving_size = serving_size

    def prepare(self) -> str:
        return f"🍽️ Preparing {self.name} - {self.serving_size} portion"

    def display(self) -> str:
        return f"🍽️ {self.name}: ${self.price:.2f} - {self.description} ({self.serving_size})"

class MainCourse(MenuItem):
    def __init__(self, name: str, price: float, description: str, cooking_time: int = 20):
        super().__init__(name, price, description)
        self.cooking_time = cooking_time

    def prepare(self) -> str:
        return f"🍳 Cooking {self.name} for {self.cooking_time} minutes"

    def get_price(self) -> float:
        return self.price + 2.50

    def display(self) -> str:
        return f"🍳 {self.name}: ${self.price:.2f} - {self.description} ({self.cooking_time}min)"

class Dessert(MenuItem):
    def __init__(self, name: str, price: float, description: str, has_whipped_cream: bool = False):
        super().__init__(name, price, description)
        self.has_whipped_cream = has_whipped_cream

    def prepare(self) -> str:
        cream = "with" if self.has_whipped_cream else "without"
        return f"🍰 Plating {self.name} {cream} whipped cream"

    def display(self) -> str:
        cream = "✨ with cream" if self.has_whipped_cream else ""
        return f"🍰 {self.name}: ${self.price:.2f} - {self.description} {cream}"

def display_menu(items):
    print("\n📋 Menu:")
    for item in items:
        print(f"  {item.display()}")
    print("-" * 40)

def prepare_order(items):
    print("\n👨‍🍳 Preparing your order:")
    for item in items:
        print(f"  {item.prepare()}")
    print("-" * 40)

def calculate_total(items):
    total = sum(item.get_price() for item in items)
    print(f"\n💰 Total: ${total:.2f}")
    return total

menu = [
    Appetizer("Bruschetta", 8.99, "Toasted bread with tomato and basil", "large"),
    Appetizer("Spring Rolls", 6.99, "Crispy vegetable rolls"),
    MainCourse("Grilled Salmon", 22.99, "Fresh salmon with lemon dill sauce", 15),
    MainCourse("Steak Frites", 28.99, "Ribeye with garlic fries", 25),
    Dessert("Tiramisu", 7.99, "Classic Italian dessert", True),
    Dessert("Panna Cotta", 6.99, "Vanilla bean custard")
]

display_menu(menu)
order = [menu[0], menu[2], menu[4]]
prepare_order(order)
calculate_total(order)

print("\n🎯 Polymorphism in action:")
for item in [menu[0], menu[2], menu[4]]:
    print(f"  {item.name} = ${item.get_price():.2f}")

💡 Try it yourself: Add a Beverage class, change pricing rules, or add a new method. Click Test to run automated tests on your changes.

03 — Practice Exercises

Level Up Your Skills

Complete these exercises in order. Each one builds on the previous concepts.

🧪 Exercise 1: Add a Beverage Category Easy Not Started

Create a Beverage class that inherits from MenuItem.

A size attribute (small, medium, large, extra large)
An is_hot boolean attribute
A prepare() method that returns a preparation message
A display() method that shows the size and temperature
Override get_price() to add $0.50 for large and $1.00 for extra large

class Beverage(MenuItem):
    def __init__(self, name, price, description, size="medium", is_hot=True):
        super().__init__(name, price, description)
        self.size = size
        self.is_hot = is_hot

    def prepare(self):
        temp = "Hot" if self.is_hot else "Iced"
        return f"☕ Preparing {temp} {self.name} ({self.size})"

    def get_price(self):
        if self.size == "large":
            return self.price + 0.50
        elif self.size == "extra large":
            return self.price + 1.00
        return self.price

    def display(self):
        temp = "☕" if self.is_hot else "🧊"
        return f"{temp} {self.name}: ${self.price:.2f} - {self.description} ({self.size})"

💡 Hint 1: Your class should inherit from MenuItem. Don't forget super().__init__()!

💡 Hint 2: In get_price(), check self.size and add the appropriate amount.

💡 Hint 3: Use ☕ for hot and 🧊 for iced in display().

🧪 Exercise 2: Debug the Menu Medium Not Started

This code has a bug that causes an AttributeError. Find and fix it:

class BrokenDessert(MenuItem):
    def __init__(self, name, price, description, is_vegan):
        self.name = name
        self.is_vegan = is_vegan

    def prepare(self):
        return f"🍰 Preparing {self.name} (Vegan: {self.is_vegan})"

    def display(self):
        return f"🍰 {self.name}: ${self.price:.2f} - Vegan: {self.is_vegan}"

💡 Hint 1: The error is in __init__. What does super() do?

💡 Hint 2: The parent needs to initialize name, price, and description.

💡 Hint 3: Add super().__init__(name, price, description) as the first line of __init__.

🧪 Exercise 3: Combo Meal (Composition) Hard Not Started

Create a ComboMeal class that contains multiple MenuItem objects and calculates a discounted total.

This exercise demonstrates composition ("has-a" relationship) rather than inheritance.

class ComboMeal:
    def __init__(self, name, items, discount=0.10):
        self.name = name
        self.items = items
        self.discount = discount

    def get_price(self):
        total = sum(item.get_price() for item in self.items)
        return total * (1 - self.discount)

    def prepare(self):
        return f"🍽️ Preparing Combo: {self.name}\n" + "\n".join(
            f"  - {item.prepare()}" for item in self.items
        )

    def display(self):
        items_str = ", ".join(item.name for item in self.items)
        return f"🍱 {self.name}: ${self.get_price():.2f} - {items_str} ({self.discount*100:.0f}% off)"

💡 Hint 1: ComboMeal contains MenuItem objects — this is composition.

💡 Hint 2: Use sum() with a generator to calculate the total.

💡 Hint 3: The get_price() method should apply the discount to the total.

🧪 Exercise 4: Fix the LSP Violation Hard Not Started

This class violates the Liskov Substitution Principle. Fix it so it works correctly.

class BadMainCourse(MainCourse):
    def __init__(self, name, price, description, cooking_time, is_spicy):
        super().__init__(name, price, description, cooking_time)
        self.is_spicy = is_spicy

    def get_price(self):
        if self.is_spicy:
            raise ValueError("Spicy dishes cannot be priced!")
        return super().get_price()

💡 Hint 1: LSP says subclasses should not throw exceptions that the parent doesn't.

💡 Hint 2: Instead of raising an error, add a surcharge for spicy dishes.

💡 Hint 3: Return super().get_price() + 1.50 for spicy dishes.

🧪 Exercise 5: Method Resolution Order (MRO) Medium Not Started

What will this code print? Try to work it out, then click "Run" to check.

class A:
    def whoami(self): return "A"

class B(A):
    def whoami(self): return "B" + super().whoami()

class C(A):
    def whoami(self): return "C" + super().whoami()

class D(B, C):
    def whoami(self): return "D" + super().whoami()

print(D().whoami())
print([cls.__name__ for cls in D.__mro__])
        

05 — Common Mistakes & Anti-Patterns

What to Avoid

Mistake	Why It's Bad	Better Approach
Forgetting `super().__init__()`	Parent attributes are never initialized	Always call `super().__init__()` first
Deep inheritance (5+ levels)	Hard to maintain, fragile	Prefer shallow hierarchies + composition
Raising exceptions in overridden methods	Breaks LSP, violates the contract	Extend behavior, don't restrict it
Base class knows about subclasses	Violates Open/Closed Principle	Keep base class generic
Overriding to change a tiny detail	Adds unnecessary complexity	Use parameters or composition
Mutable defaults in __init__	Shared state across instances	Use `None` and create fresh objects

06 — Next Steps

Continue Your Learning Journey

📐

Try Other Projects

Zoo Manager, Vehicle Garage, RPG Characters

Explore

🔍

Abstract Base Classes

Formal contracts with ABC and @abstractmethod

Coming Soon

🧩

Design Patterns

Strategy, Factory, and more

Coming Soon

🏆

Real-World Python

How Django, FastAPI use inheritance

Coming Soon

Back to Inheritance Hub

🍕 Restaurant Menu System

🎯 By the end of this module, you will be able to:

📋 Learning Progress

The Duplication Problem

Without Inheritance — Duplicated Code

The Solution: Inheritance

With Inheritance — Clean, DRY Code

The Liskov Substitution Principle (LSP)

Inheritance vs Composition

Inheritance ("is-a")

Composition ("has-a")

Build the Restaurant Menu

Level Up Your Skills

🧪 Exercise 1: Add a Beverage Category Easy Not Started

🧪 Exercise 2: Debug the Menu Medium Not Started

🧪 Exercise 3: Combo Meal (Composition) Hard Not Started

🧪 Exercise 4: Fix the LSP Violation Hard Not Started

🧪 Exercise 5: Method Resolution Order (MRO) Medium Not Started

Test Your Understanding

Question 1: What does `super().init()` do?

Question 2: Why does the base MenuItem raise NotImplementedError?

Question 3: What concept is demonstrated by calculate_total() working with any menu item?

Question 4: What is the Liskov Substitution Principle?

Question 5: When should you prefer composition over inheritance?

Question 6: What does `ClassName.mro` show?

What to Avoid

Continue Your Learning Journey

Try Other Projects

Abstract Base Classes

Design Patterns

Real-World Python

🍕 Restaurant Menu System

🎯 By the end of this module, you will be able to:

📋 Learning Progress

The Duplication Problem

Without Inheritance — Duplicated Code

The Solution: Inheritance

With Inheritance — Clean, DRY Code

The Liskov Substitution Principle (LSP)

Inheritance vs Composition

Inheritance ("is-a")

Composition ("has-a")

Build the Restaurant Menu

Level Up Your Skills

🧪 Exercise 1: Add a Beverage Category Easy Not Started

🧪 Exercise 2: Debug the Menu Medium Not Started

🧪 Exercise 3: Combo Meal (Composition) Hard Not Started

🧪 Exercise 4: Fix the LSP Violation Hard Not Started

🧪 Exercise 5: Method Resolution Order (MRO) Medium Not Started

Test Your Understanding

Question 1: What does super().__init__() do?

Question 2: Why does the base MenuItem raise NotImplementedError?

Question 3: What concept is demonstrated by calculate_total() working with any menu item?

Question 4: What is the Liskov Substitution Principle?

Question 5: When should you prefer composition over inheritance?

Question 6: What does ClassName.__mro__ show?

What to Avoid

Continue Your Learning Journey

Try Other Projects

Abstract Base Classes

Design Patterns

Real-World Python

Question 1: What does `super().init()` do?

Question 6: What does `ClassName.mro` show?