【设计模式】策略模式

我会带着你远行 2022-07-16 01:37 208阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/java-design-patterns][https_github.com_yihonglei_java-design-patterns]

# 一 策略模式作用 #

定义一个个算法，即算法族，把这些算法分别封装起来，这些算法可以相互替换，这种模式让算法的变化独立于使用

算法的客户。

# 二 应用场景 #

1）许多相关的类仅仅是行为有异，该模式提供一种用多个行为中的一个行为来配置一个类的方法。

2）需要使用一个算法的不同变体。

3）算法使用用户不应该知道的数据，使用该模式以避免暴露复杂的，与算法相关的数据结构。

# 三 UML图 #

**策略模式静态类图：**

![70][]

# 四 参与对象 #

**1）Strategy(接口定义)**

定义算法的公共接口。

**2）ConcreteStrategy(接口实现)**

实现Strategy接口，实现某些算法的具体。Context使用这个接口来调用ConcreteStrategy定义的算法。

**3）Context(提供接口引用)**

Context维护一个对Strategy对象的引用。

# 五 策略模式实战 #

**Strategy：定义算法的公共接口。**

package com.jpeony.design.patterns.strategy;
    
    /**
     * 定义所有支持的算法的公共接口(面向接口编程并不是interface接口，而是接口和超类)
     *
     * @author yihonglei
     */
    public abstract class Strategy {
        public abstract void method();
    }

**ConcreteStrategy：Strategy接口的具体实现，以下进行A和B的具体实现。**

**A算法实现：**

package com.jpeony.design.patterns.strategy;
    
    /**
     * 算法的具体实现: A算法
     *
     * @author yihonglei
     */
    public class StrategyImplA extends Strategy {
    
        @Override
        public void method() {
            System.out.println("第一个实现类--A算法");
        }
    
    }

**B算法实现：**

package com.jpeony.design.patterns.strategy;
    
    /**
     * 算发的第二个实现: B算法
     *
     * @author yihonglei
     */
    public class StrategyImplB extends Strategy {
    
        @Override
        public void method() {
            System.out.println("第二个实现类--B算法");
        }
    
    }

**Context：维护Strategy的引用，供客户端调用，而不是让客户端调用具体实现A或B。**

package com.jpeony.design.patterns.strategy;
    
    /**
     * 新建一个Context类，负责维护具体算法实现的访问，
     * 不让客户端直接访问到算法的实现
     *
     * @author yihonglei
     */
    public class Context {
        Strategy strategy;
    
        public Context(Strategy s) {
            this.strategy = s;
        }
    
        public void doMethod() {
            strategy.method();
        }
    }

**Client**

package com.jpeony.design.patterns.strategy;
    
    /**
     * 客户端通过Context维护的访问方式，访问到算法的具体实现，
     * 从代码结构，我们可以看出，客户端并没直接去访问算法的具体
     * 实现，而是通过维护的Context类去访问，算法的具体实现访问
     * 控制权在于客户端
     *
     * @author yihonglei
     */
    public class Client {
    
        public static void main(String[] args) {
            Context ctxA = new Context(new StrategyImplA());
            ctxA.doMethod();
    
            Context ctxB = new Context(new StrategyImplB());
            ctxB.doMethod();
    
        }
    
    }

**运行结果：**

![Center][]

**总结：**

客户端根据需要通过Context维护的Strategy引用去调用具体的实现，算法的具体实现未暴露给客户端，

让代码具有安全性，同时客户端使用很方便，只需选择某个算法使用即可，无需关注底层算法实现细节。

无论对于算法扩展，还是客户端扩展都是相互独立的，代码富有弹性，而并非将客户端与算法实现进行绑定。

使用策略模式有时候能榜我们减少泛滥继承，动态添加行为等带来的烦恼。

[https_github.com_yihonglei_java-design-patterns]: https://github.com/yihonglei/java-design-patterns
[70]: /images/20220716/d010c6f95bec4f358c446642c8e69b6a.png
[Center]: /images/20220716/d2515ffaf0584916b62f3015d0eb4071.png