java设计模式--策略模式

策略模式：定义了不同的算法，分别分装起来，让他们可以互相替换，即使算法变化了，也不会影响到使用算法的用户

首先定义一个抽象算法类，有两个类继承了这个抽象类，重写了AlgorithmInterface()方法

public abstract class Strategy {

    public abstract void  AlgorithmInterface();

}

public class AlgorithmA extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("实现算法A");
    }
}

public class AlgorithmB extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("实现算法B");
    }
}

用一个context类来维护对抽象算法类Strategy对象的引用(重点)

public class Context {
    Strategy strategy;
    public Context(Strategy strategy){
        this.strategy = strategy;
    }

    public void ContrxtInterface(){
        strategy.AlgorithmInterface();
    }
}

测试类1

public class Test1 {
    public static void main(String[] args) {
        Context context = null;
        context = new Context(new AlgorithmA());
        context.ContrxtInterface();

        context = new Context(new AlgorithmB());
        context.ContrxtInterface();

    }
}

但是从上面测试类1的代码我们发现是在客户端判断是用什么算法，现在我们想把这个判断交由其他类处理，于是就有了下面的策略模式与简单工厂结合的方法。

public class Context2 {
    Strategy strategy = null;

    public Context2(String type){
        switch (type){
            case "A": strategy = new AlgorithmA();
            break;
            case "B": strategy = new AlgorithmB();
            break;

        }
    }
    public void ContrxtInterface(){
        strategy.AlgorithmInterface();
    }
}

测试类2

public class Text2 {
    public static void main(String[] args) {
        Context2 context2A = new Context2("A");
        context2A.ContrxtInterface();
        Context2 context2B = new Context2("B");
        context2B.ContrxtInterface();
    }
}

结论：策略模式定义一系列算法，他们完成的都是同一件事，只是实现方法不同，比如超市收银时，会员打折，非会员不打折，实现的都是收钱，实现方法（打折/非打折）不同。

优点：1.上下文和具体策略是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。

2.策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。