大话设计模式之策略模式读后感

策略模式：定义了算法家族，分别封装起来，让他们呢之间可以互相的替换，此模式让算法的变化不会影响到使用算法的客户。

UML类图：

解读：策略模式是定义一系列的算法，从概念上来讲，这些算法完成的工作都是一样的，只是他们的实现的不同，可以以相同的方式调用所有的算法，减少了各种算法类和算法调用类之间的耦合。

策略模式中的supperStrategy为context类提供了一系列的可供重用的算法或者行为。继承有助于提取出这些算法的公共功能。

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给了策略模式中的对象context对象。

代码示例：

package com.dzf.designtest;

/**
 * <desc>
 *   策略模式：定义了一系列的算法，让这些算法之间可以互相的替换
 * <p>
 * </desc>
 *
 * @author dingzf
 * @date 2018/4/1
 * @time 11:23
 */
public class StrategyDemo {
    //客户端
    public static void main(String[] args) {
        Context context1 = new Context(new StrategyOne());
        context1.operate();
　　　　　　//当我们需要使用哪种实现的时候，就选择哪种
        Context context2 = new Context(new StrategyTwo());
        context2.operate();
        Context context3 = new Context(new StrategyThree());
        context3.operate();
    }
}


/**
 * 策略模式中的上下文对象，引用策略模式中的策略类
 */
class Context{
    private SupperStrategy supperStrategy;
    public Context(SupperStrategy supperStrategy) {
        this.supperStrategy = supperStrategy;
    }
    public void operate(){
        if(supperStrategy!=null){
            supperStrategy.getResult();
        }
    }
}

/**
 * 策略类
 */
abstract class SupperStrategy {
    public abstract void getResult();
}

/**
 * 策略子类1
 */
class StrategyOne extends SupperStrategy {
    @Override
    public void getResult() {
        System.out.println("我会策略1号");
    }
}
/**
 * 策略子类2
 */
class StrategyTwo extends SupperStrategy {
    @Override
    public void getResult() {
        System.out.println("我会策略2号");
    }
}
/**
 * 策略子类3
 */
class StrategyThree extends SupperStrategy {
    @Override
    public void getResult() {
        System.out.println("我会策略3号");
    }
}

上面这种写法还是不太好，这样我们调用端需要知道两个类，我们可以改造下：

public class StrategyDemo {
    //客户端
    public static void main(String[] args) {
      Context context1 = new Context("strategyOne");
      context1.operate();
      Context context2 = new Context("strategyTwo");
      context2.operate();
      Context context3 = new Context("strategyThree");
      context3.operate();
    }
}


/**
 * 策略模式中的上下文对象，引用策略模式中的策略类
 */
class Context{
    private SupperStrategy supperStrategy;
    public Context(String supperStrategy) {
        switch (supperStrategy){
            case "strategyOne" :
                this.supperStrategy = new StrategyOne();
                break;
            case "strategyTwo" :
                this.supperStrategy = new StrategyTwo();
                break;
            case "strategyThree" :
                this.supperStrategy = new StrategyThree();
                break;
        }
    }
    public void operate(){
        if(supperStrategy!=null){
            supperStrategy.getResult();
        }
    }
}

我们来使用简单工厂的方式来判断需要生成的对象，这样调用端只需要知道一个context类就可以啦。

选择所用具体实现的职责由客户端对象承担，并转给了策略模式中的对象context对象。

大家有没有发现代码上和简单工厂很类似，要说和简单工厂的区别，在代码上的体现就是调用端只需要知道context这个类，而使用简单工厂的时候，至少得知道两个类。进一步解耦和了吧，个人感觉策略模式是简单工厂的升级版，把策略模式和简单工厂合在一起使用更佳，当然大话设计模式里面也是推荐这样使用的。

最后：以上可以说是自己读大话涉及模式的一些读后感，如果有不对的地方，希望能够指正出来。