“设计模式系列-策略模式,状态模式”


策略模式

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

应用场景: 1.多个类只有在算法或行为上稍有不同的场景。
2.算法需要自由切换的场景。
3.需要屏蔽算法规则的场景。

s

角色: Context封装角色:屏蔽高层模块对策略、算法的直接访问,封装可能存在的变化。
Strategy抽象策略角色:策略、算法家族的抽象,通常为接口,定义每个策略或算法必须具有的方法和属性。
ConcreteStrategy具体策略角色:实现抽象策略中的操作,该类含有具体的算法。

实现:

    public class Price {
        private int type;

        public static final int TYPE_Primary = 1;  //普通会员
        public static final int TYPE_Intermediate = 2;  //中级会员
        public static final int TYPE_Advanced = 3;   //高级会员

        public void setType(int type){
            this.type = type;
        }

        /**
         * 计算图书的价格
         */
        public double quote(double booksPrice){
            if(type == TYPE_Primary){
                System.out.println("对于初级会员的没有折扣");
                return booksPrice;
            } else if(type == TYPE_Intermediate){
                System.out.println("对于中级会员的折扣为10%");
                return booksPrice * 0.9;
            } else if(type == TYPE_Advanced){
                System.out.println("对于高级会员的折扣为20%");
                return booksPrice * 0.8;
            } else {
                System.out.println("这是啥???");
                return -1;
            }
        }
    }

策略模式实现:

    public interface MemberStrategy {
        /**
         * 计算图书的价格
         * @param booksPrice    图书的原价
         * @return    计算出打折后的价格
         */
        public double calcPrice(double booksPrice);
    }

    public class PrimaryMemberStrategy implements MemberStrategy {
        @Override
        public double calcPrice(double booksPrice) {
            System.out.println("对于初级会员的没有折扣");
            return booksPrice;
        }

    }

    public class IntermediateMemberStrategy implements MemberStrategy {

        @Override
        public double calcPrice(double booksPrice) {
            System.out.println("对于中级会员的折扣为10%");
            return booksPrice * 0.9;
        }
    }

    public class AdvancedMemberStrategy implements MemberStrategy {

        @Override
        public double calcPrice(double booksPrice) {
            System.out.println("对于高级会员的折扣为20%");
            return booksPrice * 0.8;
        }
    }

    public class Price {
        //持有一个具体的策略对象
        private MemberStrategy strategy;

        public setMemberStrategy(MemberStrategy strategy){
            this.strategy = strategy;
        }

        /**
         * 计算图书的价格
         */
        public double quote(double booksPrice){
            return this.strategy.calcPrice(booksPrice);
        }
    }

策略模式的优点:
算法可以自由切换
避免使用多重条件判断
扩展性良好

策略模式的缺点:
策略类数量增多
所有的策略类都需要对外暴露

状态模式

定义:当一个对象内在状态改变时允许其改变行为,这个对象看起来像改变了其类。

应用场景:
1.行为随状态改变而改变的场景。
2.条件、分支判断语句的替代者。

s

角色:
State抽象状态角色:接口或抽象类,负责对象状态定义,并且封装环境角色以实现状态切换。
ConcreteState具体状态角色:本状态下要做的事情。
Context环境角色:定义客户端需要的接口,并且负责具体状态的切换。

    public interface MemberState {
        /**
         * 计算图书的价格
         * @param booksPrice    图书的原价
         * @return    计算出打折后的价格
         */
        public void buyBook(double booksPrice);
    }

    public class PrimaryMemberState implements MemberState {
        @Override
        public void buyBook(double booksPrice) {
            System.out.println("对于初级会员的没有折扣" + booksPrice);
        }

    }

    public class IntermediateMemberState implements MemberState {

        @Override
        public void buyBook(double booksPrice) {
            System.out.println("对于中级会员的折扣为10%" + booksPrice * 0.9);
        }
    }

    public class AdvancedMemberState implements MemberState {

        @Override
        public void buyBook(double booksPrice) {
            System.out.println("对于高级会员的折扣为20%"+ booksPrice * 0.8);
        }
    }

    public class Person {
        //持有一个具体的策略对象
        private MemberState state;

        public setMemberStrategy(MemberState state){
            this.state = state;
        }

        /**
         * 买一本书
         */
        public void buyBook(double booksPrice){
            this.state.buyBook(booksPrice);
        }
    }

策略模式vs状态模式:
问题的重点是业务关注的是什么,是状态还是工作逻辑?找准了业务的焦点,才能选择一个好的设计模式。

解决问题的重点不同:
策略模式旨在解决内部算法如何改变的问题,也就是将内部算法的改变对外界的影响降低到最小,它保证的是算法可以自由地切换;
而状态模式旨在解决内在状态的改变而引起行为改变的问题,它的出发点是事物的状态,封装状态而暴露行为,一个对象的状态改变,从外界来看就好像是行为改变。



本作品由 Tony Zhang 创作,采用 CC BY-NC-SA 3.0 许可协议 进行许可。

Comments