Strategy Pattern — UML, Code & When to Use

Swap the algorithm, not the code around it

When one task has several interchangeable implementations — payment methods, compression schemes, routing rules — the Strategy pattern puts each behind a common interface and lets the client pick one at runtime. It replaces a growing if/else (or switch) ladder with polymorphism, and is the textbook way to honour the Open/Closed Principle: add a new strategy without touching existing code.

Code

interface PaymentStrategy { void pay(int amountCents); }
class CreditCardPay implements PaymentStrategy { public void pay(int a){ /* ... */ } }
class PayPalPay     implements PaymentStrategy { public void pay(int a){ /* ... */ } }

class Checkout {                                   // the Context
    private PaymentStrategy strategy;              // swappable
    Checkout(PaymentStrategy s){ this.strategy = s; }
    void confirm(int total){ strategy.pay(total); }
}
new Checkout(new PayPalPay()).confirm(4999);       // choose at runtime

When to use — and what it's NOT

• Use when you have multiple ways to do one thing and want to choose/extend without editing a conditional ladder.
• vs State: identical structure, different intent — State's objects represent a mode and transition between themselves; Strategy's are stateless algorithms chosen by the client.
• vs Template Method: Template Method varies steps via inheritance (compile-time); Strategy varies the whole algorithm via composition (runtime) — "favour composition over inheritance."

Pitfalls

• Over-engineering: for two stable cases an if is fine; introduce Strategy when the set grows or changes.
• The client must know the strategies to choose — often paired with a Factory.

Takeaways

• Strategy = interchangeable algorithms behind an interface, chosen at runtime (composition).
• Replaces conditional ladders; satisfies Open/Closed.
• Same shape as State; differs in intent. Don't over-apply.

Re-authored for this guide; UML diagram hand-authored as SVG. Follows GoF and refactoring.guru. See also: SOLID (Open/Closed), Behavioral patterns, State.