二、策略模式

1 策略模式实际上就是应对有各种策略（实现方法）的需求。比如超市促销，有多种多样的促销策略，这时候就要想到策略模式，策略模式一般会配合工厂模式使用。

代码如下：

package com.biao.strategy.original;
/**
 * 
 * @author biao
 * 策略模式：定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用
 *        算法的客户。
 *       
 * 应用：商场各种促销方案。
 * 
 * 记忆方法：一个超类的算法家族+一个context容器。容器内通过构造方法注入一个超类的引用，容器内写一个方法，实现注入的对象去调用具体的算法。
 */
public class StrategyDemo {
    public static void main(String[] args) {
        
        //缺点：此处为逻辑部分，逻辑应该和界面分离，这里相当于判断多种方法，应该放到逻辑处理中，综合简单工厂模式，
        //将判断创建哪一种对象的逻辑放入具体类中处理。
        Context contextA = new Context(new ConcreteStrategyA());
        Context contextB = new Context(new ConcreteStrategyB());
        
        contextA.contextInterface();
        contextB.contextInterface();
        
    }
}
//抽象算法类，算法接口用于不同的实现方式
abstract class Strategy{
    abstract public void AlgorithmInterface();
}

//具体算法1
class ConcreteStrategyA extends Strategy{

    @Override
    public void AlgorithmInterface() {
        // TODO Auto-generated method stub
        System.out.println("算法一的实现方案");
    }
    
}
//具体算法2
class ConcreteStrategyB extends Strategy{
    
    @Override
    public void AlgorithmInterface() {
        // TODO Auto-generated method stub
        System.out.println("算法二的实现方案");
    }
}

//Context类，用来维护一个Strategy，然后调用该具体类的算法。其实就是通过构造方法注入。
class Context{
    Strategy strategy;
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    
    public void contextInterface(){
        strategy.AlgorithmInterface();
    }
}

如上demo中，主函数中创建容器（Context）的时候，需要用户自己注入不同的对象，实际相当于用户去判断传入什么对象，这个判断逻辑通过工厂的方法生成。（实际并没变化，容器中任然维护一个策略超类的引用）代码如下：

package com.biao.strategy.simplefactory;

/**
 * 
 * @author biao
 * 工厂模式和策略模式的简单结合。策略模式用于封装一些算法，供客户端调用。
 * 但是具体创建哪一个策略，是逻辑判断部分，利用工厂模式的多态，生成不同算法的
 * 对象，然后调用该对象的算法。
 */
public class StrategyFactoryDemo {
    public static void main(String[] args) {
        Context contextA = new Context("模式A");
        Context contextB = new Context("模式B");
        
        contextA.contextInterface();
        contextB.contextInterface();
    }
}
//抽象算法类，算法接口用于不同的实现方式
abstract class Strategy{
    abstract public void AlgorithmInterface();
}

//具体算法1
class ConcreteStrategyA extends Strategy{

    @Override
    public void AlgorithmInterface() {
        // TODO Auto-generated method stub
        System.out.println("算法一的实现方案");
    }
    
}
//具体算法2
class ConcreteStrategyB extends Strategy{
    
    @Override
    public void AlgorithmInterface() {
        // TODO Auto-generated method stub
        System.out.println("算法二的实现方案");
    }
}

//Context类，用来维护一个Strategy，然后调用该具体类的算法。
class Context{
    Strategy strategy;
    public Context(String flag){
        switch(flag){
        case "模式A":
            strategy = new ConcreteStrategyA();
            break;
        case "模式B":
            strategy = new ConcreteStrategyB();
            break;
        }
    }
    public void contextInterface(){
        if(strategy != null){//改进2 判断不是null，在操作，否则空指针
            strategy.AlgorithmInterface();
        }
    }
}