• Behavioral design pattern
• Lets clients switch out implementations

Problem illustration: switching out algorithm needs recompilation

How to let application vary the encryption algorithm at runtime?

1. The Context maintains a reference to one of the concrete strategies

2. The Strategy interface declares methods for the Context to execute

3. ConcreteStrategy classes implement different variants of the algorithm

4. The context calls the execute method on the linked strategy each time it needs to run the algorithm; the context does not know which one it uses.

5. The Client creates a specific strategy object and passes it to the context; it then uses the context to execute the strategy

• In the context class, identify an algorithm that is prone to frequent change, or conditional statements to switch algorithms at runtime
• Declare a Strategy interface common to all algorithm variants
• Extract each algorithm into its own ConcreteStrategy class
• Store a reference to a Strategy in the Context
• Clients of the Context must set a strategy

// strategy interface
public interface EncryptionStrategy {
  void encrypt(Message m);
}

// concrete strategies
public class AESEncryptionStrategy implements EncryptionStrategy {
  public void encrypt(Message m) { /* ... */ }
}
public class BlowfishEncryptionStrategy implements EncryptionStrategy {
  public void encrypt(Message m) { /* ... */ }
}

// context
public class EncryptionDecorator extends EmailDecorator {
  private EncryptionStrategy strategy;
  public final void send(Message m) {
    encrypt(m);
    super.send(m);
  }
  public void setStrategy(EncryptionStrategy s) {
    strategy = s;
  }
  private void encrypt(Message m) {
    strategy.encrypt(m);
  }  
}

Before: Conditional logic for variants, frequently changes