Background
- Creational
- Structural
- Behavioral
In this post we will lean about
Strategy Design pattern. This design pattern comes under behavioral type. This design patterns lets you
- define family of algorithms or class behaviors that can change at runtime depending on the context involved. To put it in other words
- it lets you choose your strategy from a list of predefined ones depending on what would suit your current runtime context.
Class Diagram
Above class diagram represents the program that I will be using to demonstrate Strategy pattern. Points to note here -
- Both concrete type of Strategies i.e AdditionStrategy and SubtractionStrategy implement the interface Strategy that has a common method performOperation() that each implementing class implement.
- Also note the composition relationship between Strategy class and Calculator class. It simply means Calculator class owns Strategy class and that Strategy class cannot exist meaningfully without Calculator class.
To the Code
Lets first write own interface class -
Strategy.java
1 2 3 4 5 6 7 8 9 10 | /**
*
* @author athakur
*
*/
public interface Strategy {
public int performOperation(int a, int b);
}
|
Now lets write our concrete classes that implement above class -
AdditionStrategy.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | /**
*
* @author athakur
*
*/
public class AdditionStrategy implements Strategy {
@Override
public int performOperation(int a, int b) {
return a+b;
}
}
|
SubtractionStrategy.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | /**
*
* @author athakur
*
*/
public class SubtractionStrategy implements Strategy {
@Override
public int performOperation(int a, int b) {
return a-b;
}
}
|
and finally our Calculator class - Calculator.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | /**
*
* @author athakur
*
*/
public class Calculator {
Strategy strategy;
public Strategy getStrategy() {
return strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public int calculate(int a, int b) {
return strategy.performOperation(a, b);
}
}
|
Now lets test our code. Create a class Test.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | /**
*
* @author athakur
*
*/
public class Test {
public static void main(String args[]) {
Calculator calc = new Calculator();
calc.setStrategy(new AdditionStrategy());
System.out.println("Additition : " + calc.calculate(5, 2));
calc.setStrategy(new SubtractionStrategy());
System.out.println("Subtraction : " + calc.calculate(5, 2));
}
}
|
and the output will be as expected -
Additition : 7
Subtraction : 3
Understanding the pattern via code
See how we could change the operation using a particular strategy depending on the requirement. Calculator here is own context. When we needed addition we use the Addition Strategy and when we needed Subtraction we used the Subtraction strategy. Note how the context or the Calculator remains the same but the strategy used changes. We are simply using different strategies depending on the requirement at runtime. This type of design is called Strategy pattern.
To sum up -
In Strategy pattern, objects representing various
strategies are created and a context object behavior changes depending on these strategies at runtime.
Related Links
