Strategy Pattern

# CHAPTER 14

Strategy Pattern #

1. Introduction #

2. Learning Objectives #

• Identify the algorithmic bloat caused by massive switch or if/else statements.

• Define the intent and structure of the Strategy Pattern.

• Encapsulate families of algorithms into interchangeable Strategy classes.

• Understand how to swap object behavior dynamically at runtime (Context switching).

• Compare the Strategy Pattern with the State Pattern.

3. The Core Concept #

• The Context: The main object the user interacts with (e.g., the Navigator class).

• The Strategy Interface: The contract that all algorithms must follow (e.g., RouteStrategy interface with a buildRoute() method).

• The Concrete Strategies: The encapsulated algorithms (e.g., CarStrategy, BikeStrategy).

4. Swapping at Runtime #

5. Strategy vs. Decorator #

• Decorator: *Adds* behavior to an object, wrapping it in new features.

• Strategy: *Changes* the gut behavior of an object by swapping out its core algorithm.

6. UML Diagram #

[ Context ] ---------------------> [ <<Interface>> Strategy ]
- strategy: Strategy                      + execute()
+ setStrategy(Strategy)                        ^
+ doAction() { strategy->execute() }           | (Implements)
                                   -------------------------
                                   |                       |
                       [ ConcreteStrategyA ]   [ ConcreteStrategyB ]
                         + execute()             + execute()

7. Code Example (PHP) #

<?php
// --- 1. The Strategy Interface ---
interface PaymentStrategy {
    public function pay($amount);
}

// --- 2. Concrete Strategies (The Algorithms) ---
class CreditCardPayment implements PaymentStrategy {
    public function pay($amount) {
        echo "Processing $amount using Stripe Credit Card API.\n";
    }
}

class PayPalPayment implements PaymentStrategy {
    public function pay($amount) {
        echo "Processing $amount by redirecting to PayPal OAuth.\n";
    }
}

class CryptoPayment implements PaymentStrategy {
    public function pay($amount) {
        echo "Processing $amount via Ethereum Blockchain transaction.\n";
    }
}

// --- 3. The Context (The Shopping Cart) ---
class ShoppingCart {
    private $paymentStrategy;

    // We can set a default strategy, or inject one
    public function setPaymentStrategy(PaymentStrategy $strategy) {
        $this->paymentStrategy = $strategy;
    }

    public function checkout($total) {
        if (!$this->paymentStrategy) {
            throw new Exception("Please select a payment method.");
        }
        // The Context delegates the work to the dynamic strategy!
        $this->paymentStrategy->pay($total);
    }
}

// --- 4. Client Code ---
$cart = new ShoppingCart();

// User selects Credit Card
echo "User clicked Credit Card:\n";
$cart->setPaymentStrategy(new CreditCardPayment());
$cart->checkout(100); 

// User changes mind, selects PayPal (Dynamic Runtime Swapping!)
echo "\nUser clicked PayPal instead:\n";
$cart->setPaymentStrategy(new PayPalPayment());
$cart->checkout(100);
?>

8. Best Practices #

• Eliminate Switch Statements: The ultimate "code smell" indicating you need a Strategy Pattern is a massive switch statement based on a type variable (e.g., switch ($type) { case 'A': doA(); case 'B': doB(); }). Replace the switch statement by making A and B separate Strategy classes.

9. Common Mistakes #

• Over-Engineering Trivial Logic: If you have an if/else statement that calculates a 5% tax vs a 10% tax, do not create a FivePercentTaxStrategy class. The Strategy pattern introduces multiple new files and interfaces. It should only be used when the algorithms are complex, highly volatile, and require complete decoupling.

10. Mini Project: Build an Image Compression Tool #

1. 1. Context: Create an ImageSaver class.

1. 2. Strategy: Create a CompressionStrategy interface with a compress($file) method.

1. 3. Concrete Strategies: Create JpegCompression (lossy) and PngCompression (lossless).

1. 4. Action: Write a script that loads an image, sets the Strategy to Jpeg, saves it, then dynamically swaps the strategy to Png and saves it again.

11. Practice Exercises #

1. 1. Define the primary architectural code smell (hint: large control structures) that indicates a codebase desperately needs to be refactored using the Strategy pattern.

1. 2. Explain how the Strategy pattern enables an application to change its core behavior dynamically at runtime without requiring a reboot or a new object instantiation.

12. MCQs with Answers #

13. Interview Questions #

• Q: Compare and contrast the Strategy Pattern with the State Pattern. Structurally they are nearly identical; how do their architectural intents differ?

• Q: Walk me through a refactoring process. You inherit a massive 3,000-line class with a switch statement that handles 10 different types of data export (CSV, XML, JSON). Explain exactly how you would use the Strategy pattern to break this God Class apart.

• Q: Explain how the Strategy pattern heavily relies on the SOLID "Dependency Inversion Principle."

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #