Inheritance vs Composition

# PROBLEM: class explosion from combining behaviors
class Animal:
    def eat(self): pass

class FlyingAnimal(Animal):
    def fly(self): pass

class SwimmingAnimal(Animal):
    def swim(self): pass

class FlyingSwimmingAnimal(FlyingAnimal, SwimmingAnimal):
    # Diamond inheritance -- which eat() gets called?
    pass

# Want to add running? Now you need:
# RunningAnimal, FlyingRunningAnimal, SwimmingRunningAnimal,
# FlyingSwimmingRunningAnimal... exponential explosion

// PROBLEM: tight coupling to base class internals
class Stack : public vector<int> {
    // Stack inherits ALL of vector's methods
    // Users can call push_back(), insert(), operator[] -- breaking stack semantics
    // This is Java's actual mistake with java.util.Stack extending Vector
public:
    void push(int val) { push_back(val); }
    int pop() {
        int val = back();
        pop_back();
        return val;
    }
    // But nothing stops: stack[3] = 42; or stack.insert(begin(), 99);
};

# COMPOSITION: Capabilities as injected components
from abc import ABC, abstractmethod

class MovementCapability(ABC):
    @abstractmethod
    def move(self): ...

class FlyingCapability(MovementCapability):
    def move(self):
        return "flying through the air"

class SwimmingCapability(MovementCapability):
    def move(self):
        return "swimming through water"

class RunningCapability(MovementCapability):
    def move(self):
        return "running on land"

class Animal:
    def __init__(self, name: str, capabilities: list[MovementCapability]):
        self.name = name
        self._capabilities = capabilities
    
    def move(self):
        for cap in self._capabilities:
            print(f"{self.name} is {cap.move()}")

# No inheritance explosion -- just compose capabilities
duck = Animal("Duck", [FlyingCapability(), SwimmingCapability(), RunningCapability()])
fish = Animal("Fish", [SwimmingCapability()])
penguin = Animal("Penguin", [SwimmingCapability(), RunningCapability()])

// COMPOSITION: Stack wraps vector instead of inheriting
template<typename T>
class Stack {
    vector<T> data_; // HAS-A, not IS-A
public:
    void push(T val) { data_.push_back(std::move(val)); }
    
    T pop() {
        if (data_.empty()) throw underflow_error("Stack empty");
        T val = std::move(data_.back());
        data_.pop_back();
        return val;
    }
    
    const T& top() const {
        if (data_.empty()) throw underflow_error("Stack empty");
        return data_.back();
    }
    
    bool empty() const { return data_.empty(); }
    size_t size() const { return data_.size(); }
    
    // No operator[], no insert, no random access -- stack semantics preserved
};

# GOOD: Interface inheritance (defining a contract)
class PaymentProcessor(ABC):
    @abstractmethod
    def charge(self, amount: Decimal, card: Card) -> TransactionId: ...
    
    @abstractmethod
    def refund(self, transaction_id: TransactionId) -> bool: ...

class StripeProcessor(PaymentProcessor):
    def charge(self, amount, card):
        # Stripe-specific implementation
        pass
    
    def refund(self, transaction_id):
        # Stripe-specific refund
        pass

class RazorpayProcessor(PaymentProcessor):
    def charge(self, amount, card):
        pass
    def refund(self, transaction_id):
        pass

// GOOD: Abstract interface with concrete implementations
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual void draw(Canvas& canvas) const = 0;
};

class Circle : public Shape {
    double radius_;
public:
    explicit Circle(double r) : radius_(r) {}
    double area() const override { return M_PI * radius_ * radius_; }
    double perimeter() const override { return 2 * M_PI * radius_; }
    void draw(Canvas& canvas) const override { canvas.drawCircle(radius_); }
};