设计模式之状态模式

模式定义：

所谓状态模式就是允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类

模式结构：

模式实现：

public class StatePattern {

    @Test
    public void testState() {
        Fish fish = new Fish();
        fish.hurt();
        fish.cure();
        fish.cure();
        fish.hurt();
        fish.hurt();
        fish.hurt();
        fish.rebirth();
    }

    /**
     * 小鱼人
     */
    class Fish {
        /**
         * 当前状态，当前血量
         */
        private IState cur;
        private int blood;

        /**
         * 四种状态
         */
        private IState death;
        private IState rebirth;
        private IState hurt;
        private IState cure;

        public Fish() {
            death = new Death(this);
            rebirth = new Rebirth(this);
            hurt = new Hurt(this);
            cure = new Cure(this);
            //默认状态为 满血复活状态
            cur = rebirth;
            blood = 100;
        }

        public int getBlood() {
            return blood;
        }

        public void setBlood(int blood) {
            this.blood = blood;
        }

        public IState getCur() {
            return cur;
        }

        public void setCur(IState cur) {
            this.cur = cur;
        }

        public IState getCure() {
            return cure;
        }

        public void setCure(IState cure) {
            this.cure = cure;
        }

        public IState getDeath() {
            return death;
        }

        public void setDeath(IState death) {
            this.death = death;
        }

        public IState getHurt() {
            return hurt;
        }

        public void setHurt(IState hurt) {
            this.hurt = hurt;
        }

        public IState getRebirth() {
            return rebirth;
        }

        public void setRebirth(IState rebirth) {
            this.rebirth = rebirth;
        }

        public void hurt() {
            cur.hurt();
        }

        public void cure() {
            cur.cure();
        }

        public void rebirth() {
            cur.rebirth();
        }
    }

    class Death implements IState {

        private Fish fish;

        public Death(Fish fish) {
            this.fish = fish;
        }

        @Override
        public void rebirth() {
            fish.setCur(fish.getRebirth());
            fish.setBlood(100);
            System.out.println("you are rebirth, current blood is " + fish.getBlood() + ". \n");
        }

        @Override
        public void hurt() {
            System.out.println("you are death, can't be hurt");
        }

        @Override
        public void cure() {
            System.out.println("you are death, can't be cured");
        }
    }

    class Rebirth implements IState {

        private Fish fish;

        public Rebirth(Fish fish) {
            this.fish = fish;
        }

        @Override
        public void rebirth() {
            System.out.println("you have rebirth, no rebirth again");
        }

        @Override
        public void hurt() {
            if (fish.getBlood() > 50) {
                fish.setCur(fish.getHurt());
                fish.setBlood(fish.getBlood() - 50);
                System.out.println("you have been hurt, current blood is " + fish.getBlood() + ". \n");
            } else {
                fish.setCur(fish.death);
                fish.setBlood(0);
                System.out.println("you have been hurt to death, current blood is " + fish.getBlood() + ". \n");
            }
        }

        @Override
        public void cure() {
            System.out.println("you have rebirth, no need cure");
        }
    }

    class Hurt implements IState {
        private Fish fish;

        public Hurt(Fish fish) {
            this.fish = fish;
        }

        @Override
        public void rebirth() {
            System.out.println("you are hurt, no rebirth");
        }

        @Override
        public void hurt() {
            if (fish.getBlood() > 50) {
                fish.setCur(fish.getHurt());
                fish.setBlood(fish.getBlood() - 50);
                System.out.println("you have been hurt, current blood is " + fish.getBlood() + ". \n");
            } else {
                fish.setCur(fish.death);
                fish.setBlood(0);
                System.out.println("you have been hurt to death, current blood is " + fish.getBlood() + ". \n");
            }
        }

        @Override
        public void cure() {
            fish.setCur(fish.getCure());
            fish.setBlood(fish.getBlood() + 50 > 100 ? 100 : fish.getBlood() + 50);
            System.out.println("you have been cured, current blood is " + fish.getBlood() + ". \n");

        }
    }

    class Cure implements IState {
        private Fish fish;

        public Cure(Fish fish) {
            this.fish = fish;
        }

        @Override
        public void rebirth() {
            System.out.println("you are cure, no rebirth");
        }

        @Override
        public void hurt() {
            fish.setCur(fish.getHurt());
            fish.setBlood(fish.getBlood() - 50);
            System.out.println("you have been hurt, current blood is " + fish.getBlood() + ". \n");
        }

        @Override
        public void cure() {
            fish.setCur(fish.getCure());
            fish.setBlood(fish.getBlood() + 50 > 100 ? 100 : fish.getBlood() + 50);
            System.out.println("you have been cured, current blood is " + fish.getBlood() + ". \n");
        }
    }

    /**
     * LOL英雄状态
     */
    interface IState {
        /**
         * 重生
         */
        void rebirth();

        /**
         * 受伤
         */
        void hurt();

        /**
         * 治疗
         */
        void cure();
    }
}

模式优点：

1、封装了转换规则

2、将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为

3、允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块

4、可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数

模式缺点：

1、状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱

2、状态模式对“开闭原则”的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码

适用场景：

1、对象的行为依赖于它的状态（属性）并且可以根据它的状态改变而改变它的相关行为

2、代码中包含大量与对象状态有关的条件语句