OOP Design

Polymorphism & OOP Design: The Shape-Shifter’s Guide

The Magic of Many Forms

Imagine you have a magic remote control. When you press “Play,” it works on your TV, your music player, and your video game console. The same button does different things depending on what device you’re pointing at!

That’s polymorphism in a nutshell. The word means “many forms” — one command, many behaviors.

The LEGO Box Analogy

Think of your code like a big LEGO box. Inside, you have different types of pieces:

• Encapsulation = Each LEGO piece is a sealed unit. You can’t see the inside, but you know how to connect it.
• Object Composition = You build bigger things by snapping smaller pieces together.
• Polymorphism = Any piece that fits the same connector can be swapped!

We’ll use this LEGO box throughout our journey.

Part 1: Encapsulation — The Secret Keeper

What is Encapsulation?

Encapsulation is like a treasure chest with a lock. You put your valuables inside, and only people with the right key can access them.

Simple Example:

• You have a piggy bank
• You can put coins IN (a slot on top)
• You can shake it to hear coins
• But you CAN’T reach inside and grab coins directly!

Why Does This Matter?

When we write code, we don’t want anyone (including ourselves!) to accidentally break things. Encapsulation protects our data.

class PiggyBank {
private:
    int coins = 0;  // Hidden treasure!

public:
    void addCoin() {
        coins++;
    }

    int checkBalance() {
        return coins;
    }
};

What’s happening here?

• private = The locked part. Only the piggy bank knows how many coins are inside.
• public = The slot and the shake. Anyone can use these!

Real Life Connection

Your phone has encapsulation too!

• Private: The complex circuits inside
• Public: The buttons you press and the screen you touch

You don’t need to know how the circuits work to send a text!

Part 2: Object Composition — Building Blocks

What is Object Composition?

Remember building with LEGOs? You take small pieces and snap them together to make something bigger. That’s composition!

Simple Example:

• A car is made of: wheels + engine + seats + steering wheel
• You don’t build a car from scratch — you combine parts!

The “Has-A” Relationship

When we say an object “has” another object, that’s composition.

class Engine {
public:
    void start() {
        // Vroom vroom!
    }
};

class Wheel {
public:
    void spin() {
        // Round and round!
    }
};

class Car {
private:
    Engine engine;      // Car HAS an engine
    Wheel wheels[4];    // Car HAS 4 wheels

public:
    void drive() {
        engine.start();
        for(int i = 0; i < 4; i++) {
            wheels[i].spin();
        }
    }
};

Why Composition is Powerful

Think about it this way:

graph TD
    A["Car"] --> B["Engine"]
    A --> C["Wheel x4"]
    A --> D["Seat x5"]
    B --> E["Spark Plug"]
    B --> F["Piston"]

• If the engine breaks, you replace just the engine
• If a wheel pops, you replace just the wheel
• You don’t throw away the whole car!

Same in code: If one part needs updating, you change just that part.

Part 3: Polymorphism — The Shape-Shifter

The Big Idea

Now for the star of our show! Polymorphism lets us:

1. Write one piece of code
2. That works with MANY different types
3. Each type behaves in its own special way

The Animal Choir Example

Imagine you’re conducting an animal choir. You wave your baton and say “SING!”

• The dog goes “Woof!”
• The cat goes “Meow!”
• The bird goes “Tweet!”

Same command. Different results. That’s polymorphism!

class Animal {
public:
    virtual void sing() {
        // Default: silence
    }
};

class Dog : public Animal {
public:
    void sing() override {
        // Woof!
    }
};

class Cat : public Animal {
public:
    void sing() override {
        // Meow!
    }
};

class Bird : public Animal {
public:
    void sing() override {
        // Tweet!
    }
};

The Magic Word: virtual

The virtual keyword is like telling C++: “Hey, this behavior might change in child classes. Be ready to pick the right one!”

Without virtual, it’s like a choir where everyone sings the same boring note.

Using Polymorphism

Here’s the beautiful part:

void conductChoir(Animal* animal) {
    animal->sing();
}

int main() {
    Dog buddy;
    Cat whiskers;
    Bird tweety;

    conductChoir(&buddy);    // Woof!
    conductChoir(&whiskers); // Meow!
    conductChoir(&tweety);   // Tweet!
}

One function. Three different behaviors. Magic!

How They All Work Together

Let’s build something that uses ALL THREE concepts:

The Gaming Console Example

graph TD
    A["GameConsole"] --> B["Controller"]
    A --> C["Display"]
    B --> D["Button"]
    B --> E["Joystick"]

    style A fill:#ff6b6b
    style B fill:#4ecdc4
    style C fill:#45b7d1

// ENCAPSULATION: Button hides its state
class Button {
private:
    bool pressed = false;

public:
    void push() { pressed = true; }
    void release() { pressed = false; }
    bool isPressed() { return pressed; }
};

// POLYMORPHISM: Different games respond differently
class Game {
public:
    virtual void onButtonPress() = 0;
};

class RacingGame : public Game {
public:
    void onButtonPress() override {
        // Accelerate!
    }
};

class FightingGame : public Game {
public:
    void onButtonPress() override {
        // Punch!
    }
};

// COMPOSITION: Console is built from parts
class GameConsole {
private:
    Button button;
    Game* currentGame;

public:
    void setGame(Game* game) {
        currentGame = game;
    }

    void play() {
        if(button.isPressed()) {
            currentGame->onButtonPress();
        }
    }
};

What’s Happening?

1. Encapsulation: The Button keeps its pressed state private
2. Composition: GameConsole is made of Button + Game parts
3. Polymorphism: The same button press does different things in different games!

Quick Summary

The Confidence Builder

You now understand three superpowers of OOP:

Encapsulation = Your code has secrets, and that’s okay! It keeps things safe.

Composition = Big things are made of small things. Always build with pieces.

Polymorphism = Write code once, use it everywhere. Let objects decide how to behave.

These aren’t just fancy words. They’re tools that make your code:

• Easier to understand
• Easier to change
• Easier to extend

Your Mental Model

Next time you code, think:

“Am I hiding what should be hidden?” → Encapsulation

“Am I building with smaller parts?” → Composition

“Can different objects respond differently to the same message?” → Polymorphism

You’ve got this! These concepts will feel natural with practice. Remember the LEGO box, the piggy bank, and the animal choir — and you’ll never forget.