策略模式

原文地址：https://www.jianshu.com/p/b2ab047ea687

定义一组算法，将算法都封装起来，并且是他们之间可以互换的
简单的说就是把方法封装在方法中，调用不同对象的相同方法实现的算法是不同的
类图如下

 

策略模式类图

Strategy是策略的抽象类
ConcreteStrategy是策略的具体实现类
Context是策略的管理类

假设一种场景
我们可以用不同的东西喝水，杯，碗，甚至是手捧着喝，下面用代码实现
1，首先创建一个策略的喝水接口

public interface DrinkWaterStrategy {
    void drink();
}

2，策略的具体实现类，用杯子喝水，用碗喝水，用手捧着喝水

public class Cup implements DrinkWaterStrategy {

    @Override
    public void drink() {
        System.out.println("用杯喝水");
    }
}

public class Bowl implements DrinkWaterStrategy{
    @Override
    public void drink() {
        System.out.println("用碗喝水");
    }
}

public class Hand implements DrinkWaterStrategy{
    @Override
    public void drink() {
        System.out.println("用手捧着喝水");
    }
}

3，策略的管理类

public class Person {
    private DrinkWaterStrategy drinkWaterStrategy;

    public Person(DrinkWaterStrategy drinkWaterStrategy){
        this.drinkWaterStrategy = drinkWaterStrategy;
    }

    public void drink(){
        drinkWaterStrategy.drink();
    }
}

4，调用

public class Main {
    public static void main(String[] args){
        Person person = null;
        person = new Person(new Bowl());
        person.drink();
        person = new Person(new Cup());
        person.drink();
        person = new Person(new Hand());
        person.drink();
    }
}

总结
策略模式扩展很方便，可自由切换算法，避免多重条件判断，扩展性好
会使类数量增多

还有一种比较特殊的写法，就是策略枚举代码如下

public enum  Calculator {

    ADD("+"){
        @Override
        public int exec(int a, int b) {
            return a + b;
        }
    },
    SUB("-"){
        @Override
        public int exec(int a, int b) {
            return a - b;
        }
    };

    String value;

    private Calculator(String value){
        this.value = value;
    }

    public String getValue(){
        return this.value;
    }

    public abstract int exec(int a,int b);
}

这种方式可扩展性查，适用于不经常变化的角色