策略模式

我们在平时开发中，有时候会遇到这种情况，就是一个功能有多种不同的算法实现和策略，我们需要根据不同的环境来选择不同的策略，这时候，就需要用到 策略模式了，就是创建一个能够根据所传递的参数对象的不同而具有不通行为的方法。

先看看代码实现：

public interface Processor {

    public Object process(Object input);

}

class UpProcessor implements Processor {

    /**
     * 大写转换
     *
     * @param input
     * @return
     */
    @Override
    public String process(Object input) {
        return ((String) input).toUpperCase();
    }
}

class DownProcessor implements Processor {

    /**
     * 小写转换
     *
     * @param input
     * @return
     */
    @Override
    public Object process(Object input) {
        return ((String) input).toLowerCase();
    }
}


class Apply {

    //策略
    private Processor processor;

    public void process(Object input){
        System.out.println("using " + processor.getClass().getSimpleName() + ", result: " + processor.process(input));
    }

    /**
     * 有参构造器，参数即策略
     * @param processor
     */
    public Apply(Processor processor) {
        this.processor = processor;
    }

    public static void main(String[] args) {
        //字符串初始化
        String str = "This is a String!";
        //创建 UpProcessor 对象
        UpProcessor upProcessor = new UpProcessor();
        //创建 DownProcessor 对象
        DownProcessor downProcessor = new DownProcessor();

        new Apply(upProcessor).process(str);
        new Apply(downProcessor).process(str);
    }
}

运行 Apply 类的 main 方法，打印结果如下：

using UpProcessor, result: THIS IS A STRING!
using DownProcessor, result: this is a string!

其中 Processor 为抽象策略类，提供抽象方法；UpProcessor 类和 DownProcessor 类为具体策略类，根据不同的需求进行不同的实现；upProcessor 和 downProcessor 对象就是策略，它包含要执行的代码；Apply 类为应用场景类，该类对具体策略类进行封装，提供给客户端访问。

我们在 Apply 中 process 方法中传进了两种不同的策略，可以看到两种不同的打印结果。我们可以根据不同的需求产生不同的策略，可以动态的改变对象的行为，减少代码之间的耦合。但是缺点也很明显，客户端必须知道所有的策略类，然后自己决定要使用哪一个策略。

欢迎关注公众号：一盐难进。