The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the algorithm used to be chosen at runtime. The context uses a strategy interface to call the algorithm defined by the concrete strategies. Strategy is used when there is conditional logic based on many algorithms, algorithms need to be changed independently of clients, or algorithms use data clients shouldn't know about. It provides a more flexible alternative to subclassing by allowing strategies to be mixed and matched at runtime.

1. Strategy Design Pattern
Hassan
Mukkram

2. What is a Design Pattern?
A software design pattern is a general, reusable
solution to a commonly occurring problem within a
given context in software design

3. Types of Design Patterns
Creational
Structural
Behavioural
Strategy is a behavioral design pattern

4. Strategy
In a Strategy design pattern, you will:
Define a family of algorithms
Encapsulate each one
Make them interchangeable

5. You should use Strategy when:
You have code with a lot of algorithms
You want to use these algorithms at different times
You have algorithm(s) that use data the client should
not know about

6. Strategy Class Diagram
ConcreteStrategyA
algorithmInterface()
ConcreteStrategyB
algorithmInterface()
ConcreteStrategyC
algorithmInterface()
Strategy
______________
Algorithminterface()
Context
contextInterface()

7. Strategy vs. Subclassing
Strategy can be used in place of subclassing
Strategy is more dynamic
Multiple strategies can be mixed in any combination
where subclassing would be difficult

8. Subclassing
 Subclassing Diagram
Class
functionX()
SubClass1
functionX()
SubClass2
functionX()
SubClass3
functionX()

9. Add a function
 Add functionY()
Class
functionX()
functionY()
SubClass1
functionX()
SubClass2
functionX()
SubClass3
functionX()

10. What happens?
 Need SIX classes to handle
both functions!!!
SubClass2
functionX()
functionY()
SubClass3
functionrX()
functionY()
SubClass2.1
behaviorY()
SubClass2.2
behaviorY()
SubClass1
____________
functionX()
functionY()
Class
___________
functionX()
functionY()

11. Strategy makes this easy!
 Diagram
Class
functionX()
functionY()
StrategyX
functionX()
...
StrategyY
functionY()
...

12. Benefits of Strategy
Eliminates conditional statements
Can be more efficient than case statements
Choice of implementation
Client can choose among different
implementations with different space and time
trade-offs

13. Continue…
Families of related algorithms
Alternative to subclassing
This lets you vary the algorithm dynamically, which
makes it easier to change and extend
You also avoid complex inheritance structures