Post
Ask Question

Strategy Design Pattern using Java Sample

Introduction

 
Strategy design pattern is a behavioral design pattern in which the behavior of the object is encapsulated with a common function name.
 

Where to use a Strategic design pattern?

 
We can use strategic design pattern when a different customer has a common strategy (Common operation name) but a different action to perform.
 

Why use a Strategic design pattern?

 
As discussed previously, customers have a common operation name to perform. With a strategic design pattern, we can share a common interface to all customers to perform their actions as per their need.
 
Players in this pattern
  • Strategy: Defines a contract with a common operation.
  • ConcreteStrategy: Implements contact defined by the Strategy.
  • Product: Fulfills customer requirements using ConcreteStrategy objects by referring Strategy contract. 
Now we will see a strategic design pattern with an example:
 
Problem definition: Define a common operation to student to access different actions like Addition, subtraction, multiplication, division.
 
Players in this case:
  • Strategy: operator
  • ConcreteStrategy: AddOperator, SubtractOperator, MultiplyOperator, DivisionOperator.
  • Product: Calculator 
Below is the operator contract which defines a common operation called ExecuteOperation:
  1. package com.sdp;  
  2.   
  3. public interface IOperator {  
  4.     void executeOperation(int a, int b);  
  5. }  
Below are the concrete operators which implement a contract as defined by the operator:
  1. package com.sdp;  
  2.   
  3. public class AddOperator implements IOperator {  
  4.     @Override  
  5.     public void executeOperation(int a, int b) {  
  6.         System.out.println("AddOperator result: " + (a + b));  
  7.     }  
  1. package com.sdp;  
  2.   
  3. public class SubtractOperator implements IOperator {  
  4.     @Override  
  5.     public void executeOperation(int a, int b) {  
  6.         System.out.println("SubtractOperator result: " + (a - b));  
  7.     }  
  8. }  
  1. package com.sdp;  
  2.   
  3. public class MultiplyOperator implements IOperator {  
  4.     @Override  
  5.     public void executeOperation(int a, int b) {  
  6.         System.out.println("MultiplyOperator result: " + (a * b));  
  7.     }  
  8. }  
  1. package com.sdp;  
  2.   
  3. public class DivisionOperator implements IOperator {  
  4.     @Override  
  5.     public void executeOperation(int a, int b) {  
  6.         System.out.println("DivisionOperator result: " + (a / b));  
  7.     }  
  8. }  
Below is the our product calculator which is going to used by customers with the help of operator contract:
  1. package com.sdp;  
  2.   
  3. public class Calculator {  
  4.   
  5.     private IOperator _operator;  
  6.   
  7.     public Calculator(IOperator ioperator)  
  8.     {  
  9.         _operator = ioperator;  
  10.     }  
  11.   
  12.     public void Calculate(int a, int b)  
  13.     {  
  14.         _operator.executeOperation(a, b);  
  15.     }  
  16. }
Below is the student class in where the student is using a Calculator to fulfill his/her requirement.
  1. package com.sdp;  
  2.   
  3. public class Student {  
  4.   
  5.     public static void main(String[] args) {  
  6.         Calculator oprt = new Calculator(new AddOperator());  
  7.         oprt.Calculate(20, 10);  
  8.   
  9.         oprt = new Calculator(new SubtractOperator());  
  10.         oprt.Calculate(20, 10);  
  11.   
  12.         oprt = new Calculator(new MultiplyOperator());  
  13.         oprt.Calculate(20, 10);  
  14.   
  15.         oprt = new Calculator(new DivisionOperator());  
  16.         oprt.Calculate(20, 10);  
  17.     }  
  18. }  
Below is the snap of output window of the above code:
 
 

Summary

 
In this blog, we understood about what strategy and design pattern are and how to use them.