The document discusses the strategy design pattern. It provides an overview and examples of how to implement the strategy pattern to allow algorithms or parts of an application's behavior to be selected at runtime. The key aspects covered include defining a strategy interface, implementing concrete strategies that adhere to the interface, and using a context object that references a strategy and delegates to it. Benefits include reduced conditionals, easier testing and maintenance, while costs include increased objects and constrained strategy interfaces.

1. Slide 1
Java Design Pattern
Strategy Pattern
Swapnal Agrawal
Module Lead
Ganesh Kolhe
Senior Team Lead

2. Slide 2
Outline
 Overview
 Analysis and Design
 Module and Client Implementation
 Strategy
 Variation in the Implementation
 Java API Usage
 Consequences

3. Slide 3
Overview
 Using different algorithms on some values such as sorting, filters,
etc.
 Applying some logic or calculation to return a value to the client.
 Implementing the algorithms in such a way that the correct
algorithm is provided from different available algorithms on the
client's request and the required value to the client is returned.

4. Slide 4
Analysis and Design
 There are many solutions and alternatives which seem to be very
simple and straightforward. Following are two such examples:
 Separate implementation logic from
client code.
 Create a static class with a method
and if-else or switch case ladder can
be used to fetch different algorithms.

5. Slide 5
Module Implementation
public final class Compute {
public static final int COMPUTE_SUM= 1;
public static final int COMPUTE_PRODUCT= 2;
private Compute() {}
public static double getComputedValue(int type, double
a , double b){
if (type == COMPUTE_SUM){
return a + b;
}else if (type == COMPUTE_PRODUCT){
return a * b;
}
throw new IllegalArgumentException();
}
}

6. Slide 6
Client Implementation
public class ApplicationClient {
public static void main(String[] args) {
System.out.println("Sum = "+
Compute.getComputedValue(
Compute.COMPUTE_SUM, 20, 25));
System.out.println("Product = "+
Compute.getComputedValue(
Compute.COMPUTE_PRODUCT, 7, 3));
}
}

7. Slide 7
The Design
Easy Testing
Code Reuse
Easy
Maintenance
Easy
Expansion

8. Slide 8
The Strategy
Design Pattern Type: Behavioral
Idea: Algorithm
Alias: Policy
A class defines many behaviors and these appear as multiple conditional
statements in its operations. Instead of many conditionals, move related
conditional branches into their own Strategy class.
Strategy pattern defines family of algorithms, encapsulates each one, and
makes them interchangeable.
 Strategy lets algorithms vary independently from clients that use them.
Calculations are based on the clients’ abstraction (not using the clients’
implementation or global data).

9. Slide 9
Strategy Implementation
 Define a Strategy Interface that is common to all supported
algorithms.
 Strategy Interface defines your Strategy Object’s behavior.
 Implement the Concrete Strategy classes that share the common
Strategy interface.

10. Slide 10
The Class Diagram
Client
<<interface>>
IComputeStrategy
-----------------------
Operation()
Concrete Concrete Concrete
Strategy1 Strategy2 Strategy…n

11. Slide 11
Module Implementation By Using Strategy
public interface IComputeStrategy01 {
public double getValue(double a, double b);
}
public class ComputeSum01 implements IComputeStrategy01 {
public double getValue(double a, double b) {
return a + b;
}
}
public class ComputeProduct01 implements IComputeStrategy01 {
public double getValue(double a, double b) {
return a * b;
}
}

12. Slide 12
Client Code Using the Implementation
public class StrategyApplicationClient01 {
public static void main(String[] args) {
IComputeStrategy01 compute1 = new ComputeSum01();
System.out.println("Sum = "+
compute1.getValue(20, 25));
IComputeStrategy01 compute2 = new ComputeProduct02();
System.out.println("Product = "+
compute2.getValue(7, 3));
}
}

13. Slide 13
The Strategy Design
Easy Testing
Code Reuse
Easy
Maintenance
Easy
Expansion

14. Slide 14
Variation In The Implementation
 Singleton:
 Concrete classes as singleton objects.
 Define a static method to get a singleton instance.

15. Slide 15
Strategy Implementation By Using Singleton
//singleton implementation
public final class ComputeSum02 implements IComputeStrategy02
{
private static ComputeSum02 computeSum = new ComputeSum02();
private ComputeSum02(){}
public static IComputeStrategy02 getOnlyOneInstance(){
return computeSum;
}
public double getValue(double a, double b) {
return a + b;
}
}

16. Slide 16
Client - Strategy Implementation By Using Singleton
public class StrategyApplicationClient02 {
public static void main(String[] args) {
IComputeStrategy02 compute1 =
ComputeSum02.getOnlyOneInstance();
System.out.println("Sum = "+
compute1.getValue(20, 25));
IComputeStrategy02 compute2 =
ComputeProduct02.getOnlyOneInstance();
System.out.println(“Product= "+
compute2.getValue(7, 3));
}
}

17. Slide 17
Another Variation In the Implementation
Context:
 is configured with a Concrete Strategy object.
 maintains a private reference to a Strategy object.
 may define an interface that lets Strategy access its data.
By changing the Context's Strategy, different behaviors can be
obtained.

18. Slide 18
Strategy Implementation By Using Context
public interface IComputeStrategy03 {
public double getValue(double a, double b);
}
//strategy context implementation
public class StrategyContext03 {
private IComputeStrategy03 computeStrategy;
public StrategyContext03 (IComputeStrategy03 computeStrategy){
this.computeStrategy = computeStrategy;
}
public void setComputeStrategy(IComputeStrategy03
computeStrategy){
this.computeStrategy = computeStrategy;
}
public double executeComputeStrategy(double a , double b){
return computeStrategy.getValue(a, b);
}
}

19. Slide 19
Client - Strategy Implementation By Using Context
public class StrategyApplicationClient03 {
public static void main(String[] args) {
StrategyContext03 ctx = new StrategyContext03(
ComputeSum03.getOnlyOneInstance());
System.out.println("Sum = "+
ctx.executeComputeStrategy(20, 25));
ctx.setComputeStratey(
ComputeProduct03.getOnlyOneInstance());
System.out.println("Product = "+
ctx.executeComputeStrategy(7, 3));
}
}

20. Slide 20
The Class Diagram
Client Context
<<interface>>
IComputeStrategy
-----------------------
Operation()
Concrete Concrete Concrete
Strategy1 Strategy2 Strategy…n

21. Slide 21
Java API Usage
checkInputStream and checkOutputStream uses the
Java.util.zip
strategy pattern to compute checksums on byte stream.
compare(), executed by among
Java.util.comparator
others Collections#sort().
the service() and all doXXX() methods take
HttpServletRequest and HttpServletResponse and the
Javax.servlet.http.HttpServlet
implementor has to process them (and not to get hold
of them as instance variables!).

22. Slide 22
Consequences
 Benefits
 Provides an alternative to sub classing the Context class to get a variety
of algorithms or behaviors.
 Eliminates large conditional statements.
 Provides a choice of implementations for the same behavior.
 Shortcomings
 Increases the number of objects.
 All algorithms must use the same Strategy interface.
Think twice before implementing the Strategy pattern or any other design
pattern to match your requirements.

23. Slide 23
About Cross Country Infotech
Cross Country Infotech (CCI) Pvt. Ltd. is a part of the Cross Country Healthcare (NYSE:
CCRN) group of companies. CCI specializes in providing a gamut of IT/ITES services and
is well equipped with technical expertise to provide smarter solutions to its customers.
Some of our cutting-edge technology offerings include Mobile, Web and BI Application
Development; ECM and Informix 4GL Solutions; and Technical Documentation, UI
Design and Testing services.

24. Slide 24
References
 http://paginas.fe.up.pt/~aaguiar/as/gof/hires/pat5i.htm
 http://www.oodesign.com/strategy-pattern.html

25. Slide 25
Thank You!