Strategy Pattern: Switch in Context Caused 47-Min Outage

// ❌ THE ANTI-PATTERN — what NOT to do
// Every new payment method forces us to edit this class.
// One typo here can break ALL payment methods at once.

public class NaiveOrderProcessor {

    // The payment type is passed as a raw string — brittle and error-prone
    public void processPayment(String paymentType, double amount) {\n\n        if (paymentType.equals(\"CREDIT_CARD\")) {\n            // Credit card processing logic\n            System.out.println(\"Charging $\" + amount + \" to credit card via Stripe API\");\n            System.out.println(\"Applying 1.5% transaction fee\");\n\n        } else if (paymentType.equals(\"PAYPAL\")) {\n            // PayPal processing logic — completely different flow\n            System.out.println(\"Redirecting to PayPal gateway for $\" + amount);\n            System.out.println(\"Applying 2.9% PayPal fee\");\n\n        } else if (paymentType.equals(\"CRYPTO\")) {\n            // Crypto logic — yet another completely different flow\n            System.out.println(\"Opening crypto wallet for $\" + amount + \" in BTC\");\n            System.out.println(\"Waiting for blockchain confirmation...\");\n\n        } else {\n            throw new IllegalArgumentException(\"Unknown payment type: \" + paymentType);\n        }\n    }\n\n    public static void main(String[] args) {\n        NaiveOrderProcessor processor = new NaiveOrderProcessor();\n        processor.processPayment(\"CREDIT_CARD\", 99.99);\n        processor.processPayment(\"PAYPAL\", 49.50);\n        // Adding a new payment type means coming back HERE and adding another else-if\n    }\n}",
        "output": "Charging $99.99 to credit card via Stripe API\nApplying 1.5% transaction fee\nRedirecting to PayPal gateway for $49.5\nApplying 2.9% PayPal fee"
      }

┌─────────────────────────────────────────────────────────────────┐
│                         UML Diagram: Strategy Pattern            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   ┌─────────────┐      ┌──────────────────────────┐            │
│   │   Context    │      │    <<interface>>         │            │
│   │             │      │     Strategy             │            │
│   │ - strategy   │──────▶│ + execute()             │            │
│   │ + execute()  │      └──────────────────────────┘            │
│   └─────────────┘                ▲                              │
│                                  │ implements                   │
│          ┌───────────────────────┼───────────────┐              │
│          │                       │               │              │
│ ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐│
│ │ ConcreteStrategyA│  │ ConcreteStrategyB│  │ ConcreteStrategyC││
│ │ + execute()     │  │ + execute()     │  │ + execute()     ││
│ └──────────────────┘  └──────────────────┘  └──────────────────┘│
│                                                                 │
│   Client creates strategy and injects into Context              │
└─────────────────────────────────────────────────────────────────┘

// ── BEFORE: Hard-coded if-else ──────────────────────────────
// This class must be modified every time a new algorithm is added.
class SortManager {

    public void sort(int[] data, String algorithm) {\n        if (algorithm.equals(\"quicksort\")) {\n            // quicksort logic...\n            System.out.println(\"Sorting with quicksort\");\n        } else if (algorithm.equals(\"mergesort\")) {\n            // mergesort logic...\n            System.out.println(\"Sorting with mergesort\");\n        } else {\n            throw new IllegalArgumentException(\"Unknown algorithm\");\n        }\n    }\n}\n\n// ── AFTER: Strategy Pattern ───────────────────────────────────\ninterface SortStrategy {\n    void sort(int[] data);\n}\n\nclass QuickSortStrategy implements SortStrategy {\n    public void sort(int[] data) {\n        System.out.println(\"Sorting with quicksort\");\n    }\n}\n\nclass MergeSortStrategy implements SortStrategy {\n    public void sort(int[] data) {\n        System.out.println(\"Sorting with mergesort\");\n    }\n}\n\nclass SortContext {\n    private SortStrategy strategy;\n\n    public SortContext(SortStrategy strategy) {\n        this.strategy = strategy;\n    }\n\n    public void executeSort(int[] data) {\n        strategy.sort(data);\n    }\n}\n\n// Client code selects the strategy externally\nSortContext context = new SortContext(new QuickSortStrategy());\ncontext.executeSort(data); // No if-else inside SortContext!",
        "output": "Sorting with quicksort"
      }

// ✅ THE STRATEGY PATTERN — clean, extensible, and testable

// ── STEP 1: Define the Strategy interface ──────────────────────────────────
// Every payment method MUST implement this contract.
// The Context (OrderProcessor) only ever talks to this interface.
interface PaymentStrategy {
    void pay(double amount);          // the algorithm hook
    double calculateFee(double amount); // bonus: fees are also encapsulated per strategy
}

// ── STEP 2: Concrete Strategy A — Credit Card ──────────────────────────────
class CreditCardPaymentStrategy implements PaymentStrategy {

    private final String cardHolderName;
    private final String maskedCardNumber; // store only last 4 digits for safety

    public CreditCardPaymentStrategy(String cardHolderName, String maskedCardNumber) {\n        this.cardHolderName = cardHolderName;\n        this.maskedCardNumber = maskedCardNumber;\n    }

    @Override
    public void pay(double amount) {
        double fee = calculateFee(amount);
        double totalCharged = amount + fee;
        // This class ONLY knows about credit card logic — nothing else
        System.out.printf("[Credit Card] Charging $%.2f (+ $%.2f fee = $%.2f total) "
                + "to card ending in %s for %s%n",
                amount, fee, totalCharged, maskedCardNumber, cardHolderName);
    }

    @Override
    public double calculateFee(double amount) {
        return amount * 0.015; // Stripe charges 1.5%
    }
}

// ── STEP 3: Concrete Strategy B — PayPal ───────────────────────────────────
class PayPalPaymentStrategy implements PaymentStrategy {

    private final String paypalEmail;

    public PayPalPaymentStrategy(String paypalEmail) {
        this.paypalEmail = paypalEmail;
    }

    @Override
    public void pay(double amount) {
        double fee = calculateFee(amount);
        double totalCharged = amount + fee;
        System.out.printf("[PayPal] Redirecting %s to PayPal for $%.2f "
                + "(+ $%.2f PayPal fee = $%.2f total)%n",
                paypalEmail, amount, fee, totalCharged);
    }

    @Override
    public double calculateFee(double amount) {
        return amount * 0.029; // PayPal charges 2.9%
    }
}

// ── STEP 4: Concrete Strategy C — Crypto ───────────────────────────────────
class CryptoPaymentStrategy implements PaymentStrategy {

    private final String walletAddress;

    public CryptoPaymentStrategy(String walletAddress) {
        this.walletAddress = walletAddress;
    }

    @Override
    public void pay(double amount) {
        double fee = calculateFee(amount);
        // Crypto has network fees but we pass savings on to the user
        System.out.printf("[Crypto] Sending $%.2f (network fee: $%.2f) "
                + "to wallet %s — awaiting blockchain confirmation%n",
                amount, fee, walletAddress);
    }

    @Override
    public double calculateFee(double amount) {
        return 0.50; // flat $0.50 network fee regardless of amount
    }
}

// ── STEP 5: The Context — OrderProcessor ───────────────────────────────────
// This class has NO idea which payment method is being used.
// It just calls pay() and the strategy handles everything.
class OrderProcessor {

    // Holds a reference to the interface — NOT a concrete class
    private PaymentStrategy paymentStrategy;

    // Strategy is injected via the constructor (constructor injection)
    public OrderProcessor(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    // You can also swap the strategy at runtime — powerful for multi-step checkouts
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double orderTotal) {
        System.out.println("\n=== Processing Order: $" + orderTotal + " ===");
        paymentStrategy.pay(orderTotal); // delegate — don't care HOW it's done
        System.out.println("Order confirmed. Receipt sent.");
    }
}

// ── STEP 6: Wire it all together ───────────────────────────────────────────
public class StrategyPatternPayment {

    public static void main(String[] args) {

        // Customer A pays by credit card
        PaymentStrategy creditCard = new CreditCardPaymentStrategy("Alice Johnson", "4242");
        OrderProcessor aliceCheckout = new OrderProcessor(creditCard);
        aliceCheckout.checkout(120.00);

        // Customer B pays via PayPal
        PaymentStrategy paypal = new PayPalPaymentStrategy("bob@example.com");
        OrderProcessor bobCheckout = new OrderProcessor(paypal);
        bobCheckout.checkout(75.00);

        // Customer C switches from PayPal to crypto mid-session (runtime swap!)
        PaymentStrategy crypto = new CryptoPaymentStrategy("0xABCD1234EF");
        bobCheckout.setPaymentStrategy(crypto); // hot-swap the strategy
        bobCheckout.checkout(75.00);
    }
}

// BONUS: In Java 8+, if your Strategy interface has ONE method,
// you can use lambdas as lightweight strategies — no boilerplate class needed.
// This is perfect for simple, one-off strategies defined at the call site.

@FunctionalInterface // marks this as safe to use with lambdas
interface DiscountStrategy {\n    double apply(double originalPrice);\n}

class PricingEngine {

    private DiscountStrategy discountStrategy;

    public PricingEngine(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double calculateFinalPrice(double originalPrice) {
        return discountStrategy.apply(originalPrice);
    }
}

public class StrategyWithLambda {

    public static void main(String[] args) {

        // Strategy 1: 10% off for loyal customers — defined inline as a lambda
        PricingEngine loyalCustomerPricing = new PricingEngine(
                price -> price * 0.90  // the lambda IS the strategy
        );

        // Strategy 2: Flat $5 off for newsletter subscribers
        PricingEngine newsletterPricing = new PricingEngine(
                price -> Math.max(0, price - 5.00) // never go below $0
        );

        // Strategy 3: No discount for regular customers
        PricingEngine regularPricing = new PricingEngine(
                price -> price // identity — no change
        );

        double basePrice = 45.00;

        System.out.printf("Base price:               $%.2f%n", basePrice);
        System.out.printf("Loyal customer price:     $%.2f%n", loyalCustomerPricing.calculateFinalPrice(basePrice));
        System.out.printf("Newsletter subscriber:    $%.2f%n", newsletterPricing.calculateFinalPrice(basePrice));
        System.out.printf("Regular customer price:   $%.2f%n", regularPricing.calculateFinalPrice(basePrice));
    }
}

// Clean strategy selection using an enum and a factory map

enum PaymentType {
    CREDIT_CARD, PAYPAL, CRYPTO, APPLE_PAY
}

class PaymentStrategyFactory {\n\n    private final Map<PaymentType, PaymentStrategy> strategies = new HashMap<>();\n\n    // Register strategies – called once at application start\n    public void register(PaymentType type, PaymentStrategy strategy) {\n        strategies.put(type, strategy);\n    }

    // Retrieve strategy – never returns null; fails fast with clear message
    public PaymentStrategy getStrategy(PaymentType type) {
        PaymentStrategy strategy = strategies.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException(
                "No strategy registered for payment type: " + type
            );
        }
        return strategy;
    }
}

// Usage in main / configuration
PaymentStrategyFactory factory = new PaymentStrategyFactory();
factory.register(PaymentType.CREDIT_CARD, new CreditCardPaymentStrategy("N/A", "0000"));
factory.register(PaymentType.PAYPAL, new PayPalPaymentStrategy("default@example.com"));
factory.register(PaymentType.CRYPTO, new CryptoPaymentStrategy("0x0"));

// At checkout time – no switch, no if-else
OrderProcessor processor = new OrderProcessor(factory.getStrategy(PaymentType.PAYPAL));
processor.checkout(99.99);

// Example: Comparator as a Strategy (Built-in Strategy Pattern in JDK)
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Natural order strategy
Collections.sort(names);

// Custom strategy: sort by length using lambda
Collections.sort(names, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

// Example: Functional interfaces as strategies (Java 8+)
UnaryOperator<String> upperCase = String::toUpperCase;
UnaryOperator<String> addExclamation = s -> s + "!";

// Composing strategies
UnaryOperator<String> shout = upperCase.andThen(addExclamation);

System.out.println(shout.apply("hello")); // Output: HELLO!

import java.util.function.UnaryOperator;
import java.util.stream.Stream;

public class FunctionCompositionStrategy {

    // Each discount is a small, focused strategy
    static UnaryOperator<Double> tenPercentOff = price -> price * 0.9;
    static UnaryOperator<Double> fiveDollarCoupon = price -> Math.max(0, price - 5.0);
    static UnaryOperator<Double> loyaltyBonus = price -> price > 100 ? price - 20 : price;

    public static void main(String[] args) {
        double basePrice = 150.00;

        // Combine all discount strategies into one composite strategy
        UnaryOperator<Double> allDiscounts = Stream.of(
                tenPercentOff,
                fiveDollarCoupon,
                loyaltyBonus
            ).reduce(UnaryOperator.identity()

# Python Strategy Pattern using functions (no interfaces, no boilerplate)

def credit_card_payment(amount: float):
    fee = amount * 0.015
    total = amount + fee
    print(f"[Credit Card] Charged ${amount:.2f} (+ ${fee:.2f} fee = ${total:.2f})")

def paypal_payment(amount: float):
    fee = amount * 0.029
    total = amount + fee
    print(f"[PayPal] Charged ${amount:.2f} (+ ${fee:.2f} fee = ${total:.2f})")

def crypto_payment(amount: float):
    fee = 0.50
    total = amount + fee
    print(f"[Crypto] Charged ${amount:.2f} (+ ${fee:.2f} fee = ${total:.2f})")

# Context - expects a callable strategy
class OrderProcessor:
    def __init__(self, payment_strategy):
        self._payment_strategy = payment_strategy

    def set_strategy(self, payment_strategy):
        self._payment_strategy = payment_strategy

    def checkout(self

// No code needed for this conceptual summary

// No code — this is a decision guide

// Illustrative pseudocode for each pattern's relationship context

// --- State: Object changes its own behaviour ---
class TcpConnection {
    private TcpState state;
    void open() { state.open(this); }   // state transitions internally
    void close() { state.close(this); }
}

// --- Command: Encapsulates a request ---
interface Command {
    void execute();
    void undo();
}
class SaveCommand implements Command { /* ... */ }

// --- Template Method: Fixed skeleton, overridable steps ---
abstract class DataMiner {\n    public final void mine() {\n        extract();\n        transform();\n        load();\n    }
    abstract void extract();
    abstract void transform();
    void load() { /* default */ }
}

// --- Strategy: Swappable algorithm ---
interface SortStrategy {
    void sort(int[] data);
}
class QuickSort implements SortStrategy { /* ... */ }
class MergeSort implements SortStrategy { /* ... */ }

// Example of a stateless strategy – safe to share across threads
class StatelessCryptoPaymentStrategy implements PaymentStrategy {
    // No instance fields – all state comes from method parameters
    @Override
    public void pay(double amount) {
        System.out.println("Processing crypto payment of $" + amount);
    }

    @Override
    public double calculateFee(double amount) {
        return 0.50; // pure function
    }
}

// Unit test for a strategy – isolated, no Context needed
public class CreditCardPaymentStrategyTest {\n\n    @Test\n    void testPayWithStandardAmount() {\n        PaymentStrategy strategy = new CreditCardPaymentStrategy(\"John\", \"1234\");\n        // Capture output with System.setOut or verify side effect\n        // For simplicity, just check no exception is thrown\n        assertDoesNotThrow(() -> strategy.pay(100.00));\n    }\n\n    @Test\n    void testFeeCalculation() {\n        PaymentStrategy strategy = new CreditCardPaymentStrategy(\"John\", \"1234\");\n        assertEquals(1.50, strategy.calculateFee(100.00), 0.001);\n    }\n\n    @Test\n    void testZeroAmount() {\n        PaymentStrategy strategy = new CreditCardPaymentStrategy(\"John\", \"1234\");\n        assertDoesNotThrow(() -> strategy.pay(0.0));\n    }"
      }