设计模式-策略模式（Strategy Pattern）

墨蓝 2023-07-02 11:24 6阅读 0赞

推荐：[Java设计模式汇总][Java]

## 策略模式 ##

**定义**  
定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换，且算法的变化不会影响使用算法的客户。它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

**类型**  
行为型。

**角色**

*  抽象策略（Strategy）：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
 *  具体策略（Concrete Strategy）：实现了抽象策略定义的接口，提供具体的算法实现。
 *  环境（Context）：持有一个策略类的引用，最终给应用层调用。

**例子**  
这里的例子，是关于促销活动的例子，有立减、满减、返现促销活动。

PromotionStrategy接口（抽象策略），抽象促销策略。

package com.kaven.design.pattern.behavioral.strategy;
    
    public interface PromotionStrategy { 
        void doPromotion();
    }

LiJianPromotionStrategy类（具体策略），立减促销策略类，实现了PromotionStrategy接口。

package com.kaven.design.pattern.behavioral.strategy;
    
    public class LiJianPromotionStrategy implements PromotionStrategy{ 
        public void doPromotion() { 
            System.out.println("立减促销，减10");
        }
    }

ManJianPromotionStrategy类（具体策略），满减促销策略类，实现了PromotionStrategy接口。

package com.kaven.design.pattern.behavioral.strategy;
    
    public class ManJianPromotionStrategy implements PromotionStrategy{ 
        public void doPromotion() { 
            System.out.println("满减促销，满200减20");
        }
    }

FanXianPromotionStrategy类（具体策略），返现促销策略类，实现了PromotionStrategy接口。

package com.kaven.design.pattern.behavioral.strategy;
    
    public class FanXianPromotionStrategy implements PromotionStrategy { 
        public void doPromotion() { 
            System.out.println("返现促销，满1000返50");
        }
    }

PromotionActivity类（环境），持有一个策略类的引用，最终给应用层调用。

package com.kaven.design.pattern.behavioral.strategy;
    
    public class PromotionActivity { 
        private PromotionStrategy promotionStrategy;
    
        public PromotionActivity(PromotionStrategy promotionStrategy) { 
            this.promotionStrategy = promotionStrategy;
        }
    
        public void executePromotionStrategy(){ 
            promotionStrategy.doPromotion();
        }
    }

应用层代码：

package com.kaven.design.pattern.behavioral.strategy;
    
    public class Test { 
        public static void main(String[] args) { 
            PromotionActivity promotionActivity618 = new PromotionActivity(new LiJianPromotionStrategy());
            PromotionActivity promotionActivity1111 = new PromotionActivity(new FanXianPromotionStrategy());
    
            promotionActivity618.executePromotionStrategy();
            promotionActivity1111.executePromotionStrategy();
        }
    }

输出：

立减促销，减10
    返现促销，满1000返50

这里便实现了一个简单的策略模式例子。  
下面我们将简单工厂模式和策略模式进行结合使用，当然还可以和单例模式、享元模式进行结合使用。

**结合简单工厂模式**  
[设计模式-简单工厂模式（Simple Factory Pattern）][-_Simple Factory Pattern]  
EmptyPromotionStrategy类，无促销策略类。

package com.kaven.design.pattern.behavioral.strategy;
    
    public class EmptyPromotionStrategy implements PromotionStrategy { 
        public void doPromotion() { 
            System.out.println("无促销");
        }
    }

PromotionStrategyFactory类，促销策略工厂类 。

package com.kaven.design.pattern.behavioral.strategy;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class PromotionStrategyFactory { 
        private static Map<String,PromotionStrategy> PROMOTION_STRATEGY_MAP = new HashMap<String, PromotionStrategy>();
        private static final PromotionStrategy NON_PROMOTION = new EmptyPromotionStrategy();
    
        static { 
            PROMOTION_STRATEGY_MAP.put(PromotionKey.LIJIAN,new LiJianPromotionStrategy());
            PROMOTION_STRATEGY_MAP.put(PromotionKey.FANXIAN,new FanXianPromotionStrategy());
            PROMOTION_STRATEGY_MAP.put(PromotionKey.MANJIAN,new ManJianPromotionStrategy());
        }
        private PromotionStrategyFactory(){ }
    
        public static PromotionStrategy getPromotionStrategy(String promotionKey){ 
            PromotionStrategy promotionStrategy = PROMOTION_STRATEGY_MAP.get(promotionKey);
            return promotionStrategy == null ? NON_PROMOTION : promotionStrategy;
        }
    
        private interface PromotionKey{ 
            String LIJIAN = "LIJIAN";
            String FANXIAN = "FANXIAN";
            String MANJIAN = "MANJIAN";
        }
    }

应用层代码：

package com.kaven.design.pattern.behavioral.strategy;
    
    public class NewTest { 
        public static void main(String[] args) { 
            String promotionKey = "MANJIAN";
            PromotionActivity promotionActivity =
                    new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey));
            promotionActivity.executePromotionStrategy();
        }
    }

输出：

满减促销，满200减20

**适用场景**

*  一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
 *  一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
 *  多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

**优点**

*  能够减少代码的if-else逻辑判断。
 *  可以在不改变源代码的情况下，新增接口实现类，灵活增加新算法，符合开闭原则。
 *  把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。

**缺点**

*  应用层必须明确知道所有算法的区别。
 *  每新增一个算法，就需要添加一个策略类。

如果有说错的地方，请大家不吝赐教（记得留言哦~~~~）。

[Java]: https://kaven.blog.csdn.net/article/details/104109975
[-_Simple Factory Pattern]: https://kaven.blog.csdn.net/article/details/103996017