Strategy pattern

Jump to: navigation, search

In computer programming, the strategy pattern (also known as the policy pattern) is a behavioural software design pattern that enables selecting an algorithm at runtime. The strategy pattern

  • defines a family of algorithms,
  • encapsulates each algorithm, and
  • makes the algorithms interchangeable within that family.

Strategy lets the algorithm vary independently from clients that use it.[1] Strategy is one of the patterns included in the influential book Design Patterns by Gamma et al. that popularized the concept of using design patterns to describe how to design flexible and reusable object-oriented software.

For instance, a class that performs validation on incoming data may use the Strategy pattern to select a validation algorithm depending on the type of data, the source of the data, user choice, or other discriminating factors. These factors are not known until run-time and may require radically different validation to be performed. The validation algorithms (strategies), encapsulated separately from the validating object, may be used by other validating objects in different areas of the system (or even different systems) without code duplication.

The essential requirement to implement the Strategy pattern is the ability to store a reference to some code in a data structure and retrieve it. This can be achieved by mechanisms such as the native function pointer, the first-class function, classes or class instances in object-oriented programming languages, or accessing the language implementation's internal storage of code via reflection.


The Strategy [2] design pattern is one of the twenty-three well-known GoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

The Strategy design pattern solves problems like: [3]

  • How can a class use different algorithms?
  • How can a class be configured with an algorithm?
  • How can an algorithm be selected and exchanged at run-time?

Implementing algorithms directly within the class that requires them is inflexible because it commits the class to particular algorithms and makes it impossible to change an algorithm later independently from (without having to change) the class. This stops the class from being reusable if other algorithms are required.

The Strategy design pattern describes how to solve such problems:

  • Encapsulate each algorithm in a separate (strategy) object. That is, define an interface (Strategy) for performing an algorithm, and implement the interface (algorithm).
  • A class delegates an algorithm to a strategy object instead of implementing the algorithm directly.

This makes a class independent of how an algorithm is implemented.
A class can be configured with a strategy object, which it uses to perform an algorithm, and even more, the strategy object can be exchanged at run-time.
See also the UML class and sequence diagram below.


UML class and sequence diagram

A sample UML class and sequence diagram for the Strategy design pattern.

In the above UML class diagram, the Context class that requires different algorithms doesn't implement them directly. Instead, Context refers to the Strategy interface for performing an algorithm (strategy.algorithm()), which makes the Context independent of how an algorithm is implemented. The Strategy1 and Strategy2 classes implement the Strategy interface, that is, implement (encapsulate) an algorithm.
The UML sequence diagram shows the run-time interactions: The Context object delegates an algorithm to different Strategy objects. First, Context calls algorithm() on a Strategy1 object, which performs the algorithm and returns the result to Context. Thereafter, Context calls algorithm() on a Strategy2 object, which performs the algorithm and returns the result to Context.

Class diagram

Strategy Pattern in UML
Strategy pattern in LePUS3 (legend)



The following example is in C#.

 1 using System;
 3 public class Program
 4 {
 5     public static void Main()
 6     {
 7         CalculateClient client = new CalculateClient(new Minus());
 9         Console.WriteLine("Minus: " + client.Calculate(7, 1));
11         //Change the strategy
12         client.Strategy = new Plus();
14         Console.WriteLine("Plus: " + client.Calculate(7, 1));
15     }
16 }
18 //The interface for the strategies
19 public interface ICalculate
20 {
21     int Calculate(int value1, int value2);
22 }
24 //strategies
25 //Strategy 1: Minus
26 public class Minus : ICalculate
27 {
28     public int Calculate(int value1, int value2)
29     {
30         return value1 - value2;
31     }
32 }
34 //Strategy 2: Plus
35 public class Plus : ICalculate
36 {
37     public int Calculate(int value1, int value2)
38     {
39         return value1 + value2;
40     }
41 }
43 //The client
44 public class CalculateClient
45 {
46     public ICalculate Strategy { get; set; }
48     public CalculateClient(ICalculate strategy)
49     {
50         Strategy = strategy;
51     }
53     //Executes the strategy
54     public int Calculate(int value1, int value2)
55     {
56         return Strategy.Calculate(value1, value2);
57     }
58 }


The following example is in Java.

import java.util.ArrayList;
import java.util.List;

public class StrategyPatternWiki {

    public static void main(final String[] arguments) {
        Customer firstCustomer = new Customer(new NormalStrategy());

        // Normal billing
        firstCustomer.add(1.0, 1);

        // Start Happy Hour
        firstCustomer.setStrategy(new HappyHourStrategy());
        firstCustomer.add(1.0, 2);

        // New Customer
        Customer secondCustomer = new Customer(new HappyHourStrategy());
        secondCustomer.add(0.8, 1);
        // The Customer pays

        // End Happy Hour
        secondCustomer.setStrategy(new NormalStrategy());
        secondCustomer.add(1.3, 2);
        secondCustomer.add(2.5, 1);

class Customer {

    private List<Double> drinks;
    private BillingStrategy strategy;

    public Customer(final BillingStrategy strategy) {
        this.drinks = new ArrayList<Double>();
        this.strategy = strategy;

    public void add(final double price, final int quantity) {

    // Payment of bill
    public void printBill() {
        double sum = 0;
        for (Double i : drinks) {
            sum += i;
        System.out.println("Total due: " + sum);

    // Set Strategy
    public void setStrategy(final BillingStrategy strategy) {
        this.strategy = strategy;


interface BillingStrategy {
    double getActPrice(final double rawPrice);

// Normal billing strategy (unchanged price)
class NormalStrategy implements BillingStrategy {

    public double getActPrice(final double rawPrice) {
        return rawPrice;


// Strategy for Happy hour (50% discount)
class HappyHourStrategy implements BillingStrategy {

    public double getActPrice(final double rawPrice) {
        return rawPrice*0.5;


A much simpler example in "modern Java" (Java 8 and later), using lambdas, may be found here.

Strategy and open/closed principle

Accelerate and brake behaviors must be declared in each new car model.

According to the strategy pattern, the behaviors of a class should not be inherited. Instead they should be encapsulated using interfaces. As an example, consider a car class. Two possible functionalities for car are brake and accelerate.

Since accelerate and brake behaviors change frequently between models, a common approach is to implement these behaviors in subclasses. This approach has significant drawbacks: accelerate and brake behaviors must be declared in each new Car model. The work of managing these behaviors increases greatly as the number of models increases, and requires code to be duplicated across models. Additionally, it is not easy to determine the exact nature of the behavior for each model without investigating the code in each.

The strategy pattern uses composition instead of inheritance. In the strategy pattern, behaviors are defined as separate interfaces and specific classes that implement these interfaces. This allows better decoupling between the behavior and the class that uses the behavior. The behavior can be changed without breaking the classes that use it, and the classes can switch between behaviors by changing the specific implementation used without requiring any significant code changes. Behaviors can also be changed at run-time as well as at design-time. For instance, a car object’s brake behavior can be changed from BrakeWithABS() to Brake() by changing the brakeBehavior member to:

brakeBehavior = new Brake();
/* Encapsulated family of Algorithms
 * Interface and its implementations
public interface IBrakeBehavior {
    public void brake();

public class BrakeWithABS implements IBrakeBehavior {
    public void brake() {
        System.out.println("Brake with ABS applied");

public class Brake implements IBrakeBehavior {
    public void brake() {
        System.out.println("Simple Brake applied");

/* Client that can use the algorithms above interchangeably */
public abstract class Car {
    protected IBrakeBehavior brakeBehavior;

    public void applyBrake() {

    public void setBrakeBehavior(final IBrakeBehavior brakeType) {
        this.brakeBehavior = brakeType;

/* Client 1 uses one algorithm (Brake) in the constructor */
public class Sedan extends Car {
    public Sedan() {
        this.brakeBehavior = new Brake();

/* Client 2 uses another algorithm (BrakeWithABS) in the constructor */
public class SUV extends Car {
    public SUV() {
        this.brakeBehavior = new BrakeWithABS();

/* Using the Car example */
public class CarExample {
    public static void main(final String[] arguments) {
        Car sedanCar = new Sedan();
        sedanCar.applyBrake();  // This will invoke class "Brake"

        Car suvCar = new SUV();
        suvCar.applyBrake();    // This will invoke class "BrakeWithABS"

        // set brake behavior dynamically
        suvCar.setBrakeBehavior( new Brake() );
        suvCar.applyBrake();    // This will invoke class "Brake"

This gives greater flexibility in design and is in harmony with the Open/closed principle (OCP) that states that classes should be open for extension but closed for modification.

See also


  1. ^ Eric Freeman, Elisabeth Freeman, Kathy Sierra and Bert Bates, Head First Design Patterns, First Edition, Chapter 1, Page 24, O'Reilly Media, Inc, 2004. ISBN 978-0-596-00712-6
  2. ^ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. pp. 315ff. ISBN 0-201-63361-2. 
  3. ^ "The Strategy design pattern - Problem, Solution, and Applicability". Retrieved 2017-08-12. 

External links