10 strategy pattern
TRANSCRIPT
![Page 1: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/1.jpg)
Strategy Pattern 1
Design Patterns
1. Strategy Pattern
How to design for flexibility?
![Page 2: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/2.jpg)
Strategy Pattern 2
References
• Design Patterns: Elements of Reusable Object-Oriented Software By Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Addison-Wesley. ISBN 0-201-63361-2.
• Head First Design Patterns By Eric Freeman, Elisabeth Freeman, Kathy Sierra, Bert BatesFirst Edition October 2004 ISBN 10: 0-596-00712-4
![Page 3: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/3.jpg)
Strategy Pattern 3
Existing Duck applicationDuck
quack()
swim()
display()
//other duck-like methods…
MallardDuck
display() {
// looks like a mallard}
RedHeadDuck
display() {
// looks like a redhead }
The display() method is abstract, since all duck subtypes look different
Other duck types inherit from the Duck class
. . .
Each duck subtype is responsible for implementing its own display() method
All ducks quack and swim. The superclass takes care of the implementation code
![Page 4: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/4.jpg)
Strategy Pattern 4
Inheritance
• All subclasses inherit the superclass’ properties– Variables and methods
• See Strategy0 project
![Page 5: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/5.jpg)
Strategy Pattern 5
Inheritance UML
![Page 6: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/6.jpg)
Strategy Pattern 6
Testing Mallard, RedHeadDuck classes
![Page 7: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/7.jpg)
Strategy Pattern 7
But Executives want to introduce fly capability quickly
• How to do it in a short time, like 2 days?
![Page 8: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/8.jpg)
Strategy Pattern 8
Solution #1
• No sweat!– Add a method fly() in Duck– Continue to use inheritance
![Page 9: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/9.jpg)
Strategy Pattern 9
Add a method fly() in DuckDuck
quack()
swim()
display()
fly()
//other duck-like methods…
MallardDuck
display() {
// looks like a mallard}
RedHeadDuck
display() {
// looks like a redhead }
All subclasses inherit fly()
![Page 10: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/10.jpg)
Strategy Pattern 10
See Strategy1 class
![Page 11: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/11.jpg)
Strategy Pattern 11
Executing Strategy1
![Page 12: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/12.jpg)
Strategy Pattern 12
Everything OK?
• Think harder.
![Page 13: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/13.jpg)
Strategy Pattern 13
Something seriously wrong!Duck
quack()
swim()
display()
fly()
//other duck-like methods…
MallardDuck
display() {
// looks like a mallard}
ReadHeadDuck
display() {
// looks like a redhead }
All duck types now can fly including RubberDuck
RubberDuck
quack() {
// overridden to Squeak }
display() {
// looks like a rubberduck }
![Page 14: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/14.jpg)
Strategy Pattern 14
Add an instance of RubberDuck
![Page 15: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/15.jpg)
Strategy Pattern 15
Executing Strategy2 … What?
![Page 16: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/16.jpg)
Strategy Pattern 16
Root cause?
• Applying inheritance to achieve re-use
• Poor solution for maintenance
![Page 17: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/17.jpg)
Strategy Pattern 17
How do we fix this?
• Using inheritance as before– Override the fly() method in rubber duck as in
quack()
• Will it fix the problem?– See Strategy3
![Page 18: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/18.jpg)
Strategy Pattern 18
Strategy3
![Page 19: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/19.jpg)
Strategy Pattern 19
Executing Strategy3
![Page 20: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/20.jpg)
Strategy Pattern 20
Is the problem solved?
• Any new problems?
![Page 21: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/21.jpg)
Strategy Pattern 21
Wait a minute
• How about new duck types?– Decoy duck?
• Can’t quack• Can’t fly
• How do we solve it?
![Page 22: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/22.jpg)
Strategy Pattern 22
Summary
• What have we done so far?
• What problems have we solved?
• What problems have we introduced in solving the problems?
• Is there a better way of doing things?
![Page 23: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/23.jpg)
Strategy Pattern 23
How about Interface?
• Take the fly() method out of Duck superclass
• And make a Flyable() interface– Only those ducks that fly are required to
implement the interface
• Make a Quackable interface too
![Page 24: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/24.jpg)
Strategy Pattern 24
class Duck
swim()
display()
//other duck-like methods…
MallardDuck
display()
fly()
quack()
RedHeadDuck
display()
fly()
quack()
RubberDuck
display() {
quack()
interface Flyable
fly()
Interface Quackable
quack()
![Page 25: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/25.jpg)
Strategy Pattern 25
How about this Strategy4_interface solution?
![Page 26: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/26.jpg)
Strategy Pattern 26
But
• You shoot yourself in the foot by duplicating code for every duck type that can fly and quack!
• And we have a lot of duck types
• We have to be careful about the properties – we cannot just call the methods blindly
• We have created a maintenance nightmare!
![Page 27: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/27.jpg)
Strategy Pattern 27
Re-thinking:
• Inheritance has not worked well because – Duck behavior keeps changing– Not suitable for all subclasses to have those
properties
• Interface was at first promising, but– No code re-use– Tedious
• Every time a behavior is changed, you must track down and change it in all the subclasses where it is defined
– Error prone
![Page 28: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/28.jpg)
Strategy Pattern 28
#1 Design Principle
• Identify the aspects of your application that vary and separate them from what stays the same
• So what are variable in the Duck class?– Flying behavior– Quacking behavior
• Pull these duck behaviors out of the Duck class– Create new classes for these behaviors
![Page 29: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/29.jpg)
Strategy Pattern 29
How do we design the classes to implement the fly and quack behaviors?
• Goal: to keep things flexible
• Want to assign behaviors to instances of Duck– Instantiate a new MallardDuck instance– Initialize it with a specific type of flying– Be able to change the behavior dynamically
![Page 30: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/30.jpg)
Strategy Pattern 30
#2 Design Principle
• Program to a supertype, not an implementation• Use a supertype to represent each behavior
– FlyBehavior and QuackBehavior– Each implementation of a behavior will implement one
of these supertypes
• In the past, we rely on an implementation– In superclass Duck, or– A specialized implementation in the subclass
• Now: Duck subclass will use a behavior represented in a supertype.
![Page 31: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/31.jpg)
Strategy Pattern 31
![Page 32: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/32.jpg)
Strategy Pattern 32
![Page 33: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/33.jpg)
Strategy Pattern 33
3 classes in codepublic interface FlyBehavior {
public void fly();}---------------------------------------------------------------------------------------------------------public class FlyWithWings implements FlyBehavior {
public void fly() {System.out.println("I'm flying!!");
}}---------------------------------------------------------------------------------------------------------public class FlyNoWay implements FlyBehavior {
public void fly() {System.out.println("I can't fly");
}}
![Page 34: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/34.jpg)
Strategy Pattern 34
public interface QuackBehavior {public void quack();
}
![Page 35: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/35.jpg)
Strategy Pattern 35
Specific behaviors by implementing interface QuackBehavior
public class Quack implements QuackBehavior {public void quack() {
System.out.println("Quack");}
}----------------------------------------------------------------------------public class Squeak implements QuackBehavior {
public void quack() {System.out.println("Squeak");
}}-----------------------------------------------------------------------------public class MuteQuack implements QuackBehavior {
public void quack() {System.out.println("<< Silence >>");
}}
![Page 36: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/36.jpg)
Strategy Pattern 36
![Page 37: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/37.jpg)
Strategy Pattern 37
Program to a Supertype
• “Program to a Supertype” means:– Exploit polymorphism by programming to a supertype– The actual runtime object isn’t locked into the code– The declared type of the variable should be a
supertype, usually an abstract class or interface– Objects assigned to those variables can be of any
concrete implementations of the supertype– The class declaring them need not know about the
actual object type
![Page 38: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/38.jpg)
Strategy Pattern 38
Integrating the Duck Behavior
1. Add 2 instance variables:
Duck
FlyBehavior flyBehavior
QuackBehavior quackBehavior
performQuack()
Swim()
Display()
performFly()
//OTHER duck-like methods
Instance variables hold a reference to a specific behavior at runtime
Behavior variables are declared as the behavior SUPERTYPE
These general methods replace fly() and quack()
![Page 39: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/39.jpg)
Strategy Pattern 39
2. Implement performQuack()
public abstract class Duck { // Declare two reference variables for the behavior interface types FlyBehavior flyBehavior; QuackBehavior quackBehavior; // All duck subclasses inherit these // etc
public Duck() { } public void performQuack() { quackBehavior.quack(); // Delegate to the behavior class }
![Page 40: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/40.jpg)
Strategy Pattern 40
![Page 41: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/41.jpg)
Strategy Pattern 41
3. How to set the quackBehavior variable & flyBehavior variable
public class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = new Quack();// A MallardDuck uses the Quack class to handle its quack,// so when performQuack is called, the responsibility for the
quack// is delegated to the Quack object and we get a real quack
flyBehavior = new FlyWithWings();// And it uses flyWithWings as its flyBehavior type
}
public void display() {System.out.println("I'm a real Mallard duck");
}
![Page 42: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/42.jpg)
Strategy Pattern 42
![Page 43: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/43.jpg)
Strategy Pattern 43
Testing the Duck code
Type and compile:
• Duck class and the MallardDuck class
• FlyBehavior interface and the two behavior implementation classes (FlyWithwings.java and flyNoWay.java)
• QuackBehavior interface and 3 behavior implementation classes
• Test class (MiniDuckSimulator.java)
![Page 44: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/44.jpg)
Strategy Pattern 44
// 1. Duck classpublic abstract class Duck { // Reference variables for the behavior interface types FlyBehavior flyBehavior; QuackBehavior quackBehavior; // All duck subclasses inherit these public Duck() { } abstract void display(); public void performFly() { flyBehavior.fly(); // Delegate to the behavior class } public void performQuack() { quackBehavior.quack(); // Delegate to the behavior class } public void swim() { System.out.println("All ducks float, even decoys!"); }
![Page 45: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/45.jpg)
Strategy Pattern 45
2. FlyBehavior and two behavior implementation classes
public interface FlyBehavior {public void fly();
}---------------------------------------------------------------------------------------------------------public class FlyWithWings implements FlyBehavior {
public void fly() {System.out.println("I'm flying!!");
}}---------------------------------------------------------------------------------------------------------public class FlyNoWay implements FlyBehavior {
public void fly() {System.out.println("I can't fly");
}}
![Page 46: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/46.jpg)
Strategy Pattern 46
// 3. QuackBehavior interface and 3 behavior implementation classes
public interface QuackBehavior {public void quack();
}----------------------------------------------------------------------------------------------------public class Quack implements QuackBehavior {
public void quack() {System.out.println("Quack");
}}---------------------------------------------------------------------------------------------------public class Squeak implements QuackBehavior {
public void quack() {System.out.println("Squeak");
}}---------------------------------------------------------------------------------------------------public class MuteQuack implements QuackBehavior {
public void quack() {System.out.println("<< Silence >>");
}}
![Page 47: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/47.jpg)
Strategy Pattern 47
4. Type and compile the test class (MiniDuckSimulator.java)
public class MiniDuckSimulator { public static void main(String[] args) { Duck mallard = new MallardDuck(); mallard.performQuack(); // This calls the MallardDuck's inherited performQuack() method, // which then delegates to the object's QuackBehavior // (i.e. calls quack() on the duck's inherited quackBehavior // reference) mallard.performFly(); // Then we do the same thing with MallardDuck's inherited // performFly() method. }}
![Page 48: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/48.jpg)
Strategy Pattern 48
Strategy project
![Page 49: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/49.jpg)
Strategy Pattern 49
Run MiniDuckSimulator
![Page 50: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/50.jpg)
Strategy Pattern 50
Check-in
• We have built dynamic behavior in ducks e.g. a MallardDuck– The dynamic behavior is instantiated in the
duck’s constructor
• How can we change the duck’s behavior after instantiation?
![Page 51: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/51.jpg)
Changing a duck’s behavior after instantiation
• Set the duck’s behavior type through a mutator method on the duck’s subclass
Strategy Pattern 51
![Page 52: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/52.jpg)
Strategy Pattern 52
How to set behavior dynamically?
1. Add new methods to the Duck class public void setFlyBehavior (FlyBehavior fb) { flyBehavior = fb; } public void setQuackBehavior(QuackBehavior
qb) { quackBehavior = qb; }
![Page 53: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/53.jpg)
Strategy Pattern 53
2. Make a new Duck type (ModelDuck.java)public class ModelDuck extends Duck {
public ModelDuck() {flyBehavior = new FlyNoWay(); // Model duck has no way to flyquackBehavior = new Quack();
}
public void display() {System.out.println("I'm a model duck");
}}
![Page 54: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/54.jpg)
Strategy Pattern 54
![Page 55: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/55.jpg)
Enabling ModelDuck to fly
• Use a mutator (setter) method to enable ModelDuck to fly
Strategy Pattern 55
![Page 56: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/56.jpg)
Strategy Pattern 56
3. Make a new FlyBehavior type (FlyRocketPowered.java)
public class FlyRocketPowered implements FlyBehavior {
public void fly() {
System.out.println("I'm flying with a rocket");
}
}
![Page 57: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/57.jpg)
Strategy Pattern 57
![Page 58: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/58.jpg)
Strategy Pattern 58
4. Change the test class (MiniDuckSimulator.java), add the ModelDuck, and make the ModelDuck rocket-enabled
Duck model = new ModelDuck();
model.performFly();
// call to performFly() delegates to the flyBehavior
// object set in ModelDuck's constructor
model.setFlyBehavior(new FlyRocketPowered());
// change the duck's behavior at runtime by
// invoking the model's inherited behavior setter
// method
model.performFly();
![Page 59: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/59.jpg)
Strategy Pattern 59
![Page 60: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/60.jpg)
Strategy Pattern 60
Test again
From mallardDue to
flyBehavior = new FlyNoWay();
In constructor of ModelDuck
Due to setter method inherited from Duck but set in model
![Page 61: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/61.jpg)
Strategy Pattern 61
![Page 62: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/62.jpg)
Strategy Pattern 62
Big Picture on encapsulated behaviors
Reworked class structure
![Page 63: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/63.jpg)
Strategy Pattern 63
Summary
• Reworked class structure– ducks extending Duck– fly behaviors implementing FlyBehavior– quack behaviors implementing QuackBehavior
• Think of each set of behaviors as a family of algorithms
• Relationships: IS-A, HAS-A, IMPELMENTS• Exercise: mark up the following diagram with the
relationships above
![Page 64: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/64.jpg)
Strategy Pattern 64
Duck
FlyBehavior flyBehavior
QuackBehavior quackBehavior
Swim()
Display()
performQuack()
performFly()
setFlyBehavior()
setQuackbehavior()
//OTHER duck-like methods
MallardDuck
display()
RedHeadDuck
display()
RubberDuck
display()
Encapsulated fly behavior
Encapsulated quack behavior
![Page 65: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/65.jpg)
Strategy Pattern 65
HAS-A can be better than IS-A
• Each duck has a FlyBehavior and a QuackBehavior to which it delegates flying and quacking
• Composition at work– Instead of inheriting behavior, ducks get their
behavior by being composed with the right behavior object
![Page 66: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/66.jpg)
Strategy Pattern 66
Third Design Principle
• Favor composition over inheritance– More flexibility– Encapsulate a family of algorithms into their
own set of classes– Able to change behavior at runtime
![Page 67: 10 strategy pattern](https://reader036.vdocuments.site/reader036/viewer/2022062406/558c79bfd8b42a3f318b4572/html5/thumbnails/67.jpg)
Strategy Pattern 67
Strategy Pattern
• The strategy Pattern – Defines a family of algorithms,– Encapsulates each one,– Makes them interchangeable.
• Strategy lets the algorithm vary independently from clients that use it