【策略设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

简介

策略模式（Strategy Pattern）属于行为型设计模式。将每一个算法封装到具有共同接口的独立类中，根据需要来绑定策略，使得具体实现和策略解耦。
当你想使用对象中各种不同的算法变体，使用if...else 所带来的复杂和难以维护，可使用策略模式。或者当有许多相同类，它们仅在执行某些行为时略有不同，可使用策略模式。
作用

• 策略算法可以自由切换，保持策略与执行类的松耦合。
  
• 避免使用多重条件判断，不同环境角色可以组装多个策略。
  
• 扩展性良好，可以随时增删策略行为。
  
• 体现了多用组合，少用继承。
  

实现步骤

• 建立一个策略接口。
  
• 新建多个策略行为类，实现该策略接口。
  
• 建立一个抽象环境角色类，并将策略接口组合进来。是否需要抽象类可选。
  
• 建立多个环境角色类来继承该抽象类。
  
• 可以动态改变环境角色的策略行为。
  

 

不同语言设计模式源码下载：
https://github.com/microwind/design-pattern

UML

 
Java代码

状态基础接口

1. // Strategy.java 基础策略接口
2. public interface Strategy {
3.   public void run();
4. }

复制代码

策略实现类

1. // StrategyA.java 策略A
2. public class StrategyA implements Strategy {
4.   @Override
5.   public void run() {
6.      System.out.println("StrategyA::run().");
7.   }
8. }

复制代码

1. // StrategyB.java 策略B
2. public class StrategyB implements Strategy {
4.   @Override
5.   public void run() {
6.      System.out.println("StrategyB::run().");
7.   }
8. }

复制代码

1. // StrategyC.java 策略C
2. public class StrategyC implements Strategy {
4.   @Override
5.   public void run() {
6.      System.out.println("StrategyC::run().");
7.   }
8. }

复制代码

抽象业务类

1. // Context.java 抽象业务类，聚合策略对象
2. public abstract class Context {
4.   protected Strategy strategy;
6.   public void setStrategy(Strategy strategy) {
7.     this.strategy = strategy;
8.   }
10.   public void action() {
11.     this.strategy.run();
12.   }
14. }

复制代码

具体业务类

1. // ContextCat.java 业务类构造器聚合了某策略
2. public class ContextCat extends Context {
4.   public ContextCat() {
5.     // 使用某个策略
6.     System.out.println("ContextCat::setStrategy(StrategyC).");
7.     this.setStrategy(new StrategyC());
8.   }
9. }

复制代码

1. // ContextDog.java 业务类构造器聚合了某策略
2. public class ContextDog extends Context {
3.   public ContextDog() {
4.     // 使用某个策略
5.     System.out.println("ContextDog::setStrategy(StrategyB).");
6.     this.setStrategy(new StrategyB());
7.   }
8. }

复制代码

测试调用

1.   /**
2.    * 策略模式就是根据需要给对象绑定具体策略，使得具体实现和策略可以灵活搭配。
3.    * 先声明某个具体Context对象，该对象已经绑定了具体策略，同时还可以更改策略。
4.    */
6.     // 实例化某个内容，策略已经绑定上
7.     Context contextCat = new ContextCat();
8.     contextCat.action();
10.     // 重新设置策略
11.     System.out.println("reset contextCat'strategy to StrategyA.");
12.     contextCat.setStrategy(new StrategyA());
13.     contextCat.action();
14.    
15.     // 实例化某个内容，策略已经绑定上
16.     Context contextGog = new ContextDog();
17.     contextGog.action();

复制代码

Go代码

状态基础接口

1. // Strategy.go 基础策略接口
2. // 定义一个策略接口，注意go语言数据类型即接口
3. type Strategy interface {
4.     Run()
5. }
7. // 写在接口文件的其他全局方法
8. func Init() {
9.     fmt.Println("strategy init!")
10. }

复制代码

策略实现类

1. // StrategyA.go 策略A
2. type StrategyA struct {
3. }
5. // 实现策略接口的对应方法
6. func (s *StrategyA) Run() {
7.     fmt.Println("StrategyA::Run")
8. }

复制代码

1. // StrategyB.go 策略B
2. type StrategyB struct {
3. }
5. // 实现策略接口的对应方法
6. func (s *StrategyB) Run() {
7.     fmt.Println("StrategyB::Run")
8. }

复制代码

1. // StrategyC.go 策略C
2. type StrategyC struct {
3. }
5. // 实现策略接口的对应方法
6. func (s *StrategyC) Run() {
7.     fmt.Println("StrategyC::Run")
8. }

复制代码

抽象业务类

1. // Context.go 抽象业务类，聚合策略对象
2. type Context struct {
3.     strategy Strategy
4. }
6. // 设置不同strategy，方法名首字母大写
7. func (c *Context) SetStrategy(s Strategy) {
8.     c.strategy = s
9. }
11. // 执行策略接口里面的方法
12. func (c *Context) Run() {
13.     c.strategy.Run()
14. }

复制代码

具体业务类

1. // ContextCat.go 业务类构造器聚合了某策略
2. // 定义具体执行对象，Go没有继承，用聚合来调用Context里的函数
3. type ContextCat struct {
4.     context Context
5. }
7. // 可提前绑定具体的策略
8. func (c *ContextCat) Init() {
9.     c.context.SetStrategy(&StrategyC{})
10.     fmt.Println("ContextCat::init. setStrategy(StrategyC)")
11. }
13. // 调用策略方法
14. func (c *ContextCat) Run() {
15.     fmt.Println("ContextCat::run")
16.     c.context.Run()
17. }

复制代码

1. // ContextDog.go 业务类构造器聚合了某策略
2. type ContextDog struct {
3.     context Context
4. }
6. // 可提前绑定具体的策略
7. func (c *ContextDog) Init() {
8.     c.context.SetStrategy(&StrategyB{})
9.     fmt.Println("ContextDog::init. setStrategy(StrategyB)")
10. }
12. // 调用策略方法
13. func (c *ContextDog) Run() {
14.     fmt.Println("ContextDog::run")
15.     c.context.Run()
16. }

复制代码

测试调用

1. func main() {
2.     fmt.Println("test start:")
3.     // 这里src.Init来自strategy.go文件
4.     src.Init()
6.     /**
7.      * 策略模式就是根据需要给对象绑定具体策略，使得具体实现和策略可以灵活搭配。
8.      * 先声明某个具体Context对象，该对象已经绑定了具体策略，同时还可以更改策略。
9.      */
11.     // 声明策略执行对象
12.     context := src.Context{}
14.     // 设置策略A
15.     context.SetStrategy(&src.StrategyA{})
17.     // 执行策略A，打印StrategyA
18.     context.Run()
20.     // 设置策略B
21.     context.SetStrategy(&src.StrategyB{})
22.     // 执行策略B，打印StrategyB
23.     context.Run()
25.     // 执行策略C，打印StrategyC
26.     context.SetStrategy(&src.StrategyC{})
27.     context.Run()
29.     // /*********************** 分割线 ******************************************/
31.     // 直接实例化具体执行对象，策略已经绑定
32.     contextCat := src.ContextCat{}
33.     contextCat.Init()
34.     contextCat.Run()
36.     // 直接实例化具体执行对象，策略已经绑定
37.     contextDog := src.ContextDog{}
38.     contextDog.Init()
39.     contextDog.Run()
40. }

复制代码

更多语言版本

不同语言设计模式源码：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！