java设计模式--策略模式

策略模式
策略模式使用的就是面向对象的继承和多态机制，主要有三个角色：

1、Context 封装角色
把策略，算法进行封装，避免直接访问。封装可能存在的变化

2、Strategy 抽象策略角色（抽象策略接口）
策略、算法的抽象，通常为接口，定义每一个策略和算法具有的方法和属性。

3、ConcreteStrategy 具体策略角色
实现提名策略中的操作 ，该类含有具体的算法。

示例：
有一个压缩的功能，可以提供zip,gzip 等方法压缩。通常写法如：
ZipCompress zpiCompress = new ZipCompress();
zpiCompress.Compress();
//调用其它的压缩
...

code:

public class Test {

    /**
     * 算法抽象类
     */
    static interface CompressStrategy {
        void compress();
    }

    /**
     * 算法具体实现类
     */
    static class ZipCompressStrategy implements CompressStrategy {
        @Override
        public void compress() {
            System.out.println("zpi compress");
        }
    }

    /**
     * 算法实现类
     */
    static class GzipCompressStrategy implements CompressStrategy {
        @Override
        public void compress() {
            System.out.println("gzip compress");
        }
    }

    /**
     * 封装算法类
     */
    static class CompressContext{
        CompressStrategy compress;

        public CompressContext(CompressStrategy compress) {
            this.compress = compress;
        }

        public void action(){
            this.compress.compress();
        }
    }

    public static void main(String[] args) {
        //压缩策略的封装
        CompressContext context = new CompressContext(ZipCompressStrategy::new);

        context.action();
    }
    
}

策略模式和代理模式不同之处在于，策略模式的封装角色Context和策略角色不使是同一个接口，如果是同一个接口，就是代理模式了。

enum 实现：

public class Test2 {


    enum Compress{

        ZIP("zip"){
            @Override
            public void action() {
                System.out.println("zpi compress");
            }
        },
        GZIP("gzip"){
            @Override
            public void action() {
                System.out.println("gzpi compress");
            }
        };

        //压缩类型
        private String type;

        Compress(String type) {
            this.type = type;
        }

        //获取压缩策略
        public static Compress getByType(String type){
            for (Compress compress : Compress.values()) {
                if(compress.type==type){
                    return compress;
                }
            }
            return null;
        }

        /**
         * 声明一个抽象函数，子类实现
         */
        public abstract void action();
    }

    public static void main(String[] args) {
        String compressType="zip";
        Compress compress = Compress.getByType(compressType);
        compress.action();
    }
    
}

jdk 实例，Comparator 就是一个策略接口。测试代码如下：

        String[] a = new String[10];
        Arrays.sort(a, new Comparator() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length()-s2.length();
            }
        });

在实际的工作中，不可能这么简单就是一个接口的实现。

优点：
1、算法可以自由切换，只要实现了策略接口，就是策略中的一员
2、避免了多个条件的判断，如果有多个策略，使用那一个策略就会有多重条件的判断
3、容易扩展策略，只要实现策略接口即可
缺点：
1、每一种策略都要实现策略接口，代码重用少
2、所有的策略都要对外公开，才能知道要使用那一种策略。如Comparator 接口，必须要知道有那些Comparator 实现类才能调用。
3、只能在合适的地方调用相应的策略才行。如果是Zip 压缩的，调用了Gzip 策略就不行了。