设计模式系列-策略模式，状态模式

策略模式

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

应用场景：
1.多个类只有在算法或行为上稍有不同的场景。

2.算法需要自由切换的场景。

3.需要屏蔽算法规则的场景。

strategy.png

角色：
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.条件、分支判断语句的替代者。

state.png

角色：

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状态模式：

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

解决问题的重点不同：

策略模式旨在解决内部算法如何改变的问题，也就是将内部算法的改变对外界的影响降低到最小，它保证的是算法可以自由地切换；

而状态模式旨在解决内在状态的改变而引起行为改变的问题，它的出发点是事物的状态，封装状态而暴露行为，一个对象的状态改变，从外界来看就好像是行为改变。