Strategy
- Define a family of algorithms, encapsulate each one, and make them
interchangeable.
- Strategy lets the algorithm vary independently from clients that use it.

- Strategy :
declares an interface common to all supported algorithms. Context uses this
interface to call the algorithm defined by a ConcreteStrategy.
- ConcreteStrategy
: implements the algorithm using the Strategy interface.
- Context : is configured with a
ConcreteStrategy object. maintains a reference to a Strategy object. may
define an interface that lets Strategy access its data.
- many related classes differ only in their behavior. Strategies provide a
way to configure a class with one of many behaviors.
- you need different variants of an algorithm. For example, you might define
algorithms reflecting different space/time trade-offs. Strategies can be
used when these variants are implemented as a class hierarchy of algorithms.
- an algorithm uses data that clients shouldn't know about. Use the Strategy
pattern to avoid exposing complex, algorithm-specific data structures.
- a class defines many behaviors, and these appear as multiple conditional
statements in its operations. Instead of many conditionals, move related
conditional branches into their own
Strategy class.
- Families of related algorithms. Hierarchies of Strategy classes
define a family of algorithms or behaviors for contexts to reuse.
Inheritance can help factor out common functionality of the
algorithms.
- An alternative to subclassing. Inheritance offers another way to
support a variety of algorithms or behaviors. You can subclass a Context
class directly to give it different behaviors. But this hardwires the
behavior into Context. It mixes the algorithm implementation with Context's,
making Context harder to understand, maintain, and extend. And you can't
vary the algorithm
dynamically. You wind up with many related classes whose only difference is
the algorithm or behavior they employ. Encapsulating the algorithm in
separate Strategy classes lets you vary the algorithm independently of its
context, making it easier to switch, understand, and extend.
- Strategies eliminate conditional statements. The Strategy pattern
offers an alternative to conditional statements for selecting desired
behavior. When different behaviors are lumped into
one class, it's hard to avoid using conditional statements to select the
right behavior. Encapsulating the behavior in separate Strategy classes
eliminates these conditional statements.
- A choice of implementations. Strategies can provide different
implementations of the same behavior. The client can choose among strategies
with different time and space trade-offs.