Behavioral Design Patterns

Now that your kitchen is set up (Creational Design Patterns) and well-organized (Structural Design Patterns), it's time to start cooking!

Behavioral Design Patterns define how objects communicate and interact within a system, just like how chefs, waiters, and kitchen staff coordinate to serve a perfect meal in a restaurant.

Let’s explore these patterns with real-world cooking analogies!

---

1. Observer Pattern → Waiter & Customers 📝

A waiter takes orders from multiple tables. When the food is ready, the kitchen notifies the waiter, who then serves the customers. The waiter doesn’t check constantly—they just get notified when needed.

🔹 In software: The Observer Pattern allows multiple objects (customers) to be notified automatically when the state of another object (kitchen) changes.

Java Example: Observer Pattern

import java.util.ArrayList;
import java.util.List;

// Step 1: Define an Observer interface
interface Observer {
    void update(String orderStatus);
}

// Step 2: Create a Subject (Observable)
class Kitchen {
    private List<Observer> waiters = new ArrayList<>();
    private String orderStatus;

    public void addObserver(Observer waiter) {
        waiters.add(waiter);
    }

    public void notifyObservers() {
        for (Observer waiter : waiters) {
            waiter.update(orderStatus);
        }
    }

    public void prepareOrder(String status) {
        this.orderStatus = status;
        notifyObservers(); // Notify all waiters
    }
}

// Step 3: Implement Concrete Observers
class Waiter implements Observer {
    private String name;

    public Waiter(String name) {
        this.name = name;
    }

    public void update(String orderStatus) {
        System.out.println(name + " received update: Order is " + orderStatus);
    }
}

// Step 4: Usage
public class ObserverPatternDemo {
    public static void main(String[] args) {
        Kitchen kitchen = new Kitchen();

        Waiter waiter1 = new Waiter("Waiter A");
        Waiter waiter2 = new Waiter("Waiter B");

        kitchen.addObserver(waiter1);
        kitchen.addObserver(waiter2);

        kitchen.prepareOrder("Ready to Serve!"); 
        // Output:
        // Waiter A received update: Order is Ready to Serve!
        // Waiter B received update: Order is Ready to Serve!
    }
}

🛠 Why use the Observer Pattern?
✅ Useful when multiple objects need real-time updates
✅ Avoids constant checking (polling)
✅ Commonly used in event-driven systems

---

2. Strategy Pattern → Cooking Styles 🔥

Imagine you're cooking chicken. You can fry, grill, or bake it—each method is interchangeable based on preference.

🔹 In software: The Strategy Pattern allows you to switch between different algorithms dynamically at runtime.

Java Example: Strategy Pattern

// Step 1: Define a Strategy Interface
interface CookingStrategy {
    void cook();
}

// Step 2: Implement Concrete Strategies
class FryingStrategy implements CookingStrategy {
    public void cook() {
        System.out.println("Frying the chicken 🍳");
    }
}

class GrillingStrategy implements CookingStrategy {
    public void cook() {
        System.out.println("Grilling the chicken 🔥");
    }
}

class BakingStrategy implements CookingStrategy {
    public void cook() {
        System.out.println("Baking the chicken 🍞");
    }
}

// Step 3: Create a Context Class
class Chef {
    private CookingStrategy strategy;

    public void setStrategy(CookingStrategy strategy) {
        this.strategy = strategy;
    }

    public void cookDish() {
        strategy.cook();
    }
}

// Step 4: Usage
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Chef chef = new Chef();

        chef.setStrategy(new FryingStrategy());
        chef.cookDish(); // Output: Frying the chicken 🍳

        chef.setStrategy(new GrillingStrategy());
        chef.cookDish(); // Output: Grilling the chicken 🔥
    }
}

🛠 Why use the Strategy Pattern?
✅ Enables dynamic switching of behaviors
✅ Promotes the Open-Closed Principle (easy to add new strategies)
✅ Avoids long conditional statements

---

3. Command Pattern → Restaurant Ordering System 📋

In a restaurant, a waiter takes orders, but the chef executes them. The waiter doesn’t care how the food is prepared—just that the order gets fulfilled.

🔹 In software: The Command Pattern separates request initiation (waiter) from execution (chef), making it easy to handle undo actions, logging, and queuing.

Java Example: Command Pattern

import java.util.ArrayList;
import java.util.List;

// Step 1: Define a Command Interface
interface Order {
    void execute();
}

// Step 2: Create Concrete Commands
class BurgerOrder implements Order {
    public void execute() {
        System.out.println("Cooking a burger 🍔");
    }
}

class PizzaOrder implements Order {
    public void execute() {
        System.out.println("Preparing a pizza 🍕");
    }
}

// Step 3: Create an Invoker (Waiter)
class Waiter {
    private List<Order> orders = new ArrayList<>();

    public void takeOrder(Order order) {
        orders.add(order);
    }

    public void serveOrders() {
        for (Order order : orders) {
            order.execute();
        }
        orders.clear();
    }
}

// Step 4: Usage
public class CommandPatternDemo {
    public static void main(String[] args) {
        Waiter waiter = new Waiter();

        waiter.takeOrder(new BurgerOrder());
        waiter.takeOrder(new PizzaOrder());

        waiter.serveOrders();
        // Output:
        // Cooking a burger 🍔
        // Preparing a pizza 🍕
    }
}

🛠 Why use the Command Pattern?
✅ Decouples request and execution
✅ Supports undo functionality
✅ Ideal for task queuing and macros

---

Why Behavioral Patterns Matter?

Just as a well-managed restaurant ensures smooth operations, Behavioral Design Patterns create efficient and flexible communication between objects.

When to use Behavioral Design Patterns?

✅ When objects need to react to state changes (Observer Pattern)
✅ When you need interchangeable algorithms (Strategy Pattern)
✅ When requests and execution should be decoupled (Command Pattern)

---

Final Thoughts

Think of Behavioral Design Patterns as streamlining the cooking process—ensuring that all elements of the system communicate effectively. By mastering these patterns, you can build scalable, efficient, and maintainable software.

Would you like to explore more patterns in depth? Drop your thoughts in the comments! 🚀