Strategy Design Pattern Implementation using Java

What is Strategy Design Pattern?

Strategy design pattern, also called as policy design pattern is utilized for managing (i) algorithms, (ii) relationships and (iii) responsibilities among the objects. Strategy design pattern is a behaviour pattern. In this pattern, a class algorithm or its behaviour can be altered during run time.

Few Strategy design pattern examples include

Documents being saved in various file formats like .docx, .html, .rtf and excel documents saved as .xls, .csv.
Files being compressed by .zip, .rar and image files being compressed as .jpeg, .png, .bmp, .tif
Using various formats like bar chart, points etc, for plotting the same statistics.

Purpose of Strategy Design Pattern

Strategy design pattern is intended to define a group of algorithms, then encapsulate each of the algorithms and permit them to become interchangeable. Strategy aims at letting the algorithm differ independently from Clients who are using it.

Strategy Design Pattern Implementation using Java

Strategy design pattern is now demonstrated with an example. It is illustrated step by step.

Step 1: First a Strategy interface is created which describes an operation.

OperationStrategy.java

public interface OperationStrategy {
	   public int arithmeticOperation(int m, int n);
}

public interface OperationStrategy {

public int arithmeticOperation(int m, int n);

}

Step 2: In the next step, concrete classes are created. Here three implementations are made, one each for addition, subtraction and multiplication.

Addition.java

public class Addition implements OperationStrategy{
	   @Override
	   public int arithmeticOperation(int m, int n) {
	      return m + n;
	   }
}

public class Addition implements OperationStrategy{

@Override

public int arithmeticOperation(int m, int n) {

return m + n;

}

Subtraction.java

public class Subtraction implements OperationStrategy{
	@Override
	   public int arithmeticOperation(int m, int n) {
	      return m - n;
	   }
}

public class Subtraction implements OperationStrategy{

@Override

public int arithmeticOperation(int m, int n) {

return m - n;

}

Multiplication.java

public class Multiplication implements OperationStrategy{
	   @Override
	   public int arithmeticOperation(int m, int n) {
	      return m * n;
	   }
}

public class Multiplication implements OperationStrategy{

@Override

public int arithmeticOperation(int m, int n) {

return m * n;

}

Step 3: The Context Class is created in the next step. The context is used for observing the alteration in its behavior when the strategy is altered.

OperationContext.java

public class OperationContext {
	   private OperationStrategy strategy;

	   public OperationContext(OperationStrategy strategy){
	      this.strategy = strategy;
	   }
	   public int performStrategy(int m, int n){
	      return strategy.arithmeticOperation(m, n);
	   }
}

public class OperationContext {

private OperationStrategy strategy;

public OperationContext(OperationStrategy strategy){

this.strategy = strategy;

}

public int performStrategy(int m, int n){

return strategy.arithmeticOperation(m, n);

}

Step 4: As shown below, StrategyPatternTrial, the demo class, will utilize OperationContext and strategy objects for representing alteration in Context behaviour on the basis of the strategy it uses.

StrategyPatternTrial.java

public class StrategyPatternTrial {
	public static void main(String[] args) {
	      OperationContext context = new OperationContext(new Addition());		
	      System.out.println("12 + 4 = " + context.performStrategy(12,4));
	      context = new OperationContext(new Subtraction());		
	      System.out.println("12 - 4 = " + context.performStrategy(12, 4));

	      context = new OperationContext(new Multiplication());		
	      System.out.println("12 * 4 = " + context.performStrategy(12, 4));
	   }
}

public class StrategyPatternTrial {

public static void main(String[] args) {

OperationContext context = new OperationContext(new Addition());

System.out.println("12 + 4 = " + context.performStrategy(12,4));

context = new OperationContext(new Subtraction());

System.out.println("12 - 4 = " + context.performStrategy(12, 4));

context = new OperationContext(new Multiplication());

System.out.println("12 * 4 = " + context.performStrategy(12, 4));

}

Step 5: After execution, output of the above program would be:

12 + 4 = 16
12 – 4 = 8
12 * 4 = 48

Related Posts

Reader Interactions

Leave a Reply Cancel reply

Footer