Python OOP — Method Overriding, Static Methods & Static Variables

The Story That Ties These Three Ideas Together

Meet All Three at a Glance

Static Variables — The Shop's Posted Rules

A static variable is a value defined directly under the class line, not inside __init__. There is exactly one copy in memory and every instance reads from it.

class Drink:
    # ══ STATIC VARIABLES — one copy, shared by every drink ══
    STANDARD_CUP_ML  = 250
    MAX_BREW_TEMP_C  = 95
    TAX_RATE         = 0.10
    CURRENCY         = "$"

    def __init__(self, base_price):
        # INSTANCE variables — one per drink
        self.base_price = base_price

# Read via the class (canonical form)
print(Drink.STANDARD_CUP_ML)   # 250
print(Drink.TAX_RATE)          # 0.1
print(Drink.CURRENCY)          # $

# Every instance sees the same value — it's not copied per drink
d1 = Drink(3); d2 = Drink(5); d3 = Drink(4)
print(d1.TAX_RATE, d2.TAX_RATE, d3.TAX_RATE)     # 0.1 0.1 0.1

Animated Diagram — One Posted Rulebook, Every Drink Reads It

Static Methods — The Shared Utility Shelf

A static method is defined with the @staticmethod decorator and takes no self and no cls. It's a plain function that happens to live inside the class namespace. Use it for validators, converters, formatters, and pure calculations.

class Drink:
    STANDARD_CUP_ML = 250
    TAX_RATE        = 0.10

    def __init__(self, base_price):
        self.base_price = base_price

    # ══ STATIC METHOD — pure input → output, no self, no cls ══
    @staticmethod
    def celsius_to_fahrenheit(c):
        return c * 9 / 5 + 32

    @staticmethod
    def is_valid_size(size_ml):
        return 25 <= size_ml <= 500

    @staticmethod
    def calculate_total(price):
        # Uses the class-level constant — but no self/cls needed
        return price * (1 + Drink.TAX_RATE)


# Call BEFORE any drink exists — that's the whole point
print(Drink.celsius_to_fahrenheit(65))   # 149.0
print(Drink.is_valid_size(200))           # True
print(Drink.is_valid_size(1000))          # False
print(Drink.calculate_total(5.00))       # 5.5 (with 10% tax)

Animated Diagram — Static Method as a Pure Function

Method Overriding — Same Call, Different Behaviour

Method overriding is the moment a child class defines a method with the same name as one in its parent. When the method is called on the child, Python uses the child's version — the parent's version is silently ignored. This is what makes polymorphism possible: many types respond to the same command in different ways.

class Drink:
    def __init__(self, size_ml, base_price):
        self.size_ml   = size_ml
        self.base_price = base_price

    # A generic prepare() — subclasses will override this
    def prepare(self):
        print("Preparing a generic drink — hot water in a cup.")


class Espresso(Drink):
    # ── OVERRIDE — same name, brand-new implementation ──
    def prepare(self):
        print(f"Espresso ({self.size_ml}ml): grind beans, tamp, extract 25s.")


class Latte(Drink):
    def prepare(self):
        print(f"Latte ({self.size_ml}ml): pull espresso, steam milk to 65°C, pour art.")


class Cappuccino(Drink):
    def prepare(self):
        print(f"Cappuccino ({self.size_ml}ml): equal parts espresso, milk, foam.")


# Same call, different result — that's polymorphism
for drink in [Espresso(30, 3), Latte(250, 5), Cappuccino(180, 4.5)]:
    drink.prepare()

Animated Diagram — One Call, Three Different Outcomes

A single loop calls drink.prepare() on each of the three drinks. Watch how the same method name lights up a different code path in each subclass — and each produces its own distinct output.

Override + Extend — Using super() to Keep Parent Behaviour

Sometimes you don't want to replace the parent's method — you want to extend it. Call super().method() from within your override to run the parent's version first, then add your own logic.

class Drink:
    def __init__(self, size_ml, base_price):
        self.size_ml    = size_ml
        self.base_price = base_price

    def prepare(self):
        print("  1. Warm the cup")
        print("  2. Fill with liquid")


class FlavouredLatte(Drink):
    def __init__(self, size_ml, base_price, syrup):
        super().__init__(size_ml, base_price)
        self.syrup = syrup

    def prepare(self):
        super().prepare()                       # run the parent's steps first
        print(f"  3. Add {self.syrup} syrup")    # then extend
        print("  4. Steam milk and pour")


drink = FlavouredLatte(250, 5.50, syrup="vanilla")
drink.prepare()

Putting All Three Together — The Complete Coffee Shop

A single hierarchy that uses static variables (shop rules), static methods (utility functions), and method overriding (each drink's unique preparation). This is the real payoff.

class Drink:
    # ══ STATIC VARIABLES — shared across every drink and every subclass ══
    STANDARD_CUP_ML  = 250
    MAX_BREW_TEMP_C  = 95
    TAX_RATE         = 0.10
    CURRENCY         = "$"

    def __init__(self, size_ml, base_price):
        if not Drink.is_valid_size(size_ml):     # uses a STATIC METHOD
            raise ValueError(f"{size_ml}ml is out of range")
        self.size_ml    = size_ml
        self.base_price = base_price

    # ── Generic prepare — subclasses OVERRIDE this ──
    def prepare(self):
        print("Generic drink: hot water, done.")

    # ── Instance method — uses static variable for its calculation ──
    def price_receipt(self):
        total = Drink.calculate_total(self.base_price)
        return f"  Price: {Drink.CURRENCY}{self.base_price:.2f} + tax → {Drink.CURRENCY}{total:.2f}"

    # ══ STATIC METHODS — utility functions grouped with the class ══
    @staticmethod
    def is_valid_size(size_ml):
        return 25 <= size_ml <= 500

    @staticmethod
    def celsius_to_fahrenheit(c):
        return c * 9 / 5 + 32

    @staticmethod
    def calculate_total(price):
        return price * (1 + Drink.TAX_RATE)


class Espresso(Drink):
    def __init__(self):
        super().__init__(size_ml=30, base_price=3.00)

    # OVERRIDE — Espresso has its own steps
    def prepare(self):
        print(f"[Espresso {self.size_ml}ml] grind → tamp → extract for 25s")


class Latte(Drink):
    def __init__(self):
        super().__init__(size_ml=250, base_price=5.00)

    def prepare(self):
        temp_f = Drink.celsius_to_fahrenheit(65)     # uses a STATIC METHOD
        print(f"[Latte {self.size_ml}ml] pull espresso → steam milk to 65°C ({temp_f}°F) → pour art")


class Cappuccino(Drink):
    def __init__(self):
        super().__init__(size_ml=180, base_price=4.50)

    def prepare(self):
        print(f"[Cappuccino {self.size_ml}ml] equal parts espresso + steamed milk + foam")


class FlavouredLatte(Latte):
    def __init__(self, syrup):
        super().__init__()
        self.syrup = syrup
        self.base_price += 0.75              # flavour surcharge

    # OVERRIDE + EXTEND — run parent's Latte prepare, then add syrup step
    def prepare(self):
        super().prepare()
        print(f"              → finish with {self.syrup} syrup")


# ── Use the static method BEFORE any drink exists ────────────
print("Valid 150ml cup?", Drink.is_valid_size(150))
print("Valid 900ml cup?", Drink.is_valid_size(900))
print("Brew temp in F:", Drink.celsius_to_fahrenheit(Drink.MAX_BREW_TEMP_C))
print()

# ── Same loop, polymorphic dispatch on prepare() ─────────────
menu = [Espresso(), Latte(), Cappuccino(), FlavouredLatte(syrup="vanilla")]
for drink in menu:
    drink.prepare()                    # dispatched to the right override
    print(drink.price_receipt())         # inherited from Drink, uses static var + method
    print()

When to Reach for Each Tool — Decision Grid

Common Mistakes (and Fixes)

Quick Reference

Golden Rules