设计模式——策略模式

作者: 不学无数的程序员 | 来源:发表于2019-04-22 16:29 被阅读1次

    设计模式——策略模式

    定义一组算法,将每个算法都封装起来,并且使得他们之间可以相互替换。

    先从一个小例子我们慢慢引出策略模式。例如我们经常初学Java的时候肯定想着做一个计算器,简单的加减乘除运算,现在我们只考虑简单的两个数字的加减。有非常多的实现方式,但是我们初学时脑海中第一浮现的应该是下面的代码。

    class Calculator{
        
        private final static String ADD = "+";
        private final static String SUB = "-";
        
        public int exec(int a, int b,String symbol){
            int result = 0;
            if (ADD.equals(symbol)){
                result = add(a,b);
            }else if (SUB.equals(symbol)){
                result = sub(a,b);
            }
            return result;
        }
        
        private int add(int a,int b){
            return a+b;
        }
    
        private int sub(int a,int b){
            return a-b;
        }
    }
    
    

    此时我们想要优化代码,因为根据上面对于策略模式的定义,我们可以抽象出其实add和sub方法都是一个算法,我们可以将其抽象出来。

    interface Calculator{
    
        public int exec(int a,int b);
    }
    
    //加法
    class AddCalculator implements Calculator{
    
        @Override
        public int exec(int a, int b) {
            return a+b;
        }
    }
    //减法
    class SubCalculator implements Calculator{
    
        @Override
        public int exec(int a, int b) {
            return a-b;
        }
    }
    
    

    根据定义我们将加法和减法两个算法都封装了起来,那么后面的可以使其相互替换是什么意思呢?其实就是根据传入不同的算法执行相应不同的方法,那么根据此来定义一个中间人进行转换。

    class Context{
        
        private Calculator calculator = null;
        
        public Context(Calculator calculator){
            this.calculator = calculator;
        }
        
        public int exec(int a, int b){
            return this.calculator.exec(a,b);
        }
    }
    
    

    这样在使用的时候,可以对于不同算法的转换。

            Context context = null;
            context = new Context(new AddCalculator());
            System.out.println(context.exec(3,2));
            context = new Context(new SubCalculator());
            System.out.println(context.exec(3,2));
    
    

    那么策略模式的类图我们也可以由此推断出来。

    image

    上面有三个角色

    • Strategy:抽象的策略模式。里面定义了每个具体的策略类要实现的定义。
    • ConcreteStrategy:具体的操作。
    • Context:承上启下的作用,传入具体的策略类,执行不同的方法。

    策略模式就是这么简单,它就是采用了面向对象的继承和多态的机制。其他的没什么玄机。

    其实上面的加减法我们还可以进一步的优化,这里就提出了策略枚举的说法。

    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 value;
        }
    
        public abstract int exec(int a, int b);
    }
    
    

    我们再进行调用的话就更加简单了。

    System.out.println(Calculator.ADD.exec(3,2));
    System.out.println(Calculator.SUB.exec(3,2));
    
    

    为什么上面的代码叫做策略枚举你呢?枚举没问题,因为他是Enum类,那么为什么是策略呢?找找看能不能找到策略的影子在里面。是的我们定义了一个抽象的exec方法。然后在每个枚举成员里面进行了实现。这样是不是和策略模式定义是一样的,对于算法进行了封装有各自实现,并且能够切换。

    注意:策略枚举是一个非常优秀和方便的模式,但是它受到枚举类型的限制,每个枚举项都是public、final、static的,扩展性受到了一定的约束,因此在开发中,策略枚举一般担当不经常发生变化的角色。

    参考

    相关文章

      网友评论

        本文标题:设计模式——策略模式

        本文链接:https://www.haomeiwen.com/subject/nacugqtx.html