设计模式：策略模式

一 场景

在软件开发中，有许多算法可以实现某一功能，如需要提供多种查找算法，可以将这些算法写到一个类中，在该类中提供多个方法，每一个方法对应一个具体的算法；当然也可以将这些查找算法封装在一个统一的方法中，通过if…else…等条件判断语句来进行选择。但是如果需要增加一种新的算法，需要修改封装算法类的源代码；更换算法，也需要修改客户端调用代码。在这个算法类中封装了大量算法，该类代码将较复杂，维护较为困难。于是我们策略模式便登场了。

二 定义

策略模式：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化。
这个模式涉及到三个角色：

• 环境(Context)角色：持有一个Strategy的引用。
• 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

• 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

  
  IntStrategy.png
  

  Strategy:

package headFirst.strategyPattern;

/**
 * @author zhaokai008@ke.com
 * @date 2019-06-26 22:56
 */
public interface Strategy<T> {

    public Boolean diffStrategy(T source,T target);
}

ConcreteStrategy:

package headFirst.strategyPattern;

/**
 * @author zhaokai008@ke.com
 * @date 2019-06-26 22:59
 */
public class IntStrategy implements Strategy<Integer> {
    public Boolean diffStrategy(Integer source, Integer target) {
        return source == target;
    }
}
//-----------------------------

package headFirst.strategyPattern;

import java.util.List;

/**
 * @author zhaokai008@ke.com
 * @date 2019-06-26 23:11
 */
public class ListStrategy extends StringStrategy {

    public Boolean diffStrategy(List<String> source, List<String> target) {
        String sourceString = null;
        String targetString =null;
        return super.diffStrategy(sourceString,targetString);
    }


}
//--------------------------
package headFirst.strategyPattern;

import java.util.List;

/**
 * @author zhaokai008@ke.com
 * @date 2019-06-26 23:13
 */
public class StringStrategy implements Strategy<String> {
    public Boolean diffStrategy(String source, String target) {
        return source.equals(target);
    }
}

Context:

package headFirst.strategyPattern;

/**
 * @author zhaokai008@ke.com
 * @date 2019-06-26 22:52
 */
public class Diff {

    private Strategy  strategy;

    public Diff(Strategy strategy){
        this.strategy  = strategy;
    }

    public void diffResult(Object source,  Object target){
        if(strategy.diffStrategy(source,target)){
            System.out.println("is same");
        }else {
            System.out.println("is not same");
        }
    }


}

test:

package headFirst.strategyPattern;

/**
 * @author zhaokai008@ke.com
 * @date 2019-06-26 22:36
 */
public class StartegyPatternTest {


    public static   void main(String  [] args ){
        Strategy strategy =  new IntStrategy();
        Strategy strategy1 = new StringStrategy();
        Diff intDiff = new Diff(strategy);
        intDiff.diffResult(1,2);
        Diff stringDiff = new Diff(strategy1);
        stringDiff.diffResult("1","1");
    }

}
//------------input:
is not same
is same

三 优点

• 对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。
• 策略模式提供了管理相关的算法族的办法。
• 策略模式提供了可以替换继承关系的办法。
• 使用策略模式可以避免使用多重条件转移语句

四 缺点

• 客户端必须知道所有的策略类，并自行决定使用哪一个策略类