设计模式（七）策略模式

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

public abstract class Strategy {
    public abstract void AlgorithmInterface();
}
public class ConcreteStrategyA extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyA的具体实现");
    }
}
public class ConcreteStrategyB extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyB的具体实现");
    }
}
public class ConcreteStrategyC extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyC的具体实现");
    }
}
public class Context {
    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}
public class Main {
    public static void main(String[] args) {
        Context context=new Context(new ConcreteStrategyA());
        context.ContextInterface();
        Context context1=new Context(new ConcreteStrategyB());
        context1.ContextInterface();
        Context context2=new Context(new ConcreteStrategyC());
        context2.ContextInterface();
    }
}

上面的例子中，对于客户端来说需要知道具体的ConcreteStrategyA,ConcreteStrategyB,ConcreteStrategyC,这样并不好

为了解决这个问题，可以将客户端的一部分转移到Context中实现

策略模式与简单工厂模式的结合

public abstract class Strategy {
    public abstract void AlgorithmInterface();
}
public class ConcreteStrategyA extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyA的具体实现");
    }
}
public class ConcreteStrategyB extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyB的具体实现");
    }
}
public class ConcreteStrategyC extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyC的具体实现");
    }
}
public class Context {
    Strategy strategy;
    public Context(String type) {
        switch (type)
        {
            case "A":
                strategy=new ConcreteStrategyA();
                break;
            case"B":
                strategy=new ConcreteStrategyB();
                break;
            case"C":
                strategy=new ConcreteStrategyC();
                break;
        }
    }
    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}
public class Main {
    public static void main(String[] args) {
        Context context=new Context("A");
        context.ContextInterface();
        Context context1=new Context("B");
        context1.ContextInterface();
        Context context2=new Context("C");
        context2.ContextInterface();
    }
}

策略模式的解析：

策略模式是一种定义一系列算法的方法，从概念上来看，所有的这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合

策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取这些算法的公共功能，策略模式的另一个优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

注：

简单工厂模式+策略模式并不是一个很好的解决办法，不符合开放扩展原则

策略模式里的switch语句可以用抽象工厂+反射得到更好的解决

设计模式（七）策略模式

猜你喜欢