行为型模式（五）状态模式

一句话的概要

允许一个对象在内部改变其对象的行为。让对象看起来就像是改变了它的类。

剧情

恋爱会改变一个人的态度，小明和女神今天回想起恋爱时候的态度，偶然提到。恋爱之前，小明请女神吃饭，约会，女神都是拒绝的。

现在请女神吃饭，约会，女神缺欣然接收。这就是两人状态的不同，导致的不同结果。

那么我们用状态模式，去构造以上场景。让女神不同的状态，做出不同的反应。

任务一：创建恋爱的抽象类

我们创建恋爱时期的抽象类，定义反应方法。我们后面会继承这个抽象类，并进行不同的反应。

public abstract class Love
    {
        //状态
        public Account Account { get; set; }

        //好感度
        public int GoodWill { get; set; }

        //吃饭
        public abstract void Eat();

        //约会
        public abstract void YueHui();

        //增加好感度
        public abstract void AddGoodWill(int good);

        //减少好感度
        public abstract void DelGoodWill(int good);
    }

我们的Account就是状态类，不同的方法就是由这里制定的。

接着我们直接看Account类的代码

public class Account
    {
        public Love love { get; set; }

        public Account(int good)
        {
            love = new Friend(0, this);
        }

        public void Eat()
        {
            love.Eat();
        }

        public void YueHui()
        {
            love.YueHui();
        }

        public void DelGoodWill(int good)
        {
            love.DelGoodWill(good);
        }
    }

我们让他们两个人，从朋友开始。所以构造的话，初始化朋友。并且定义不同的方法，调用女神反应的抽象方法。

这样继承的话，只需要改对应的抽象方法即可。

任务二：创建朋友的反应

我们先创建朋友的反应，直接上代码。

public class Friend : Love
    {
        public Friend(int good, Account love)
        {
            this.GoodWill = good;
            this.Account = love;
        }

        public override void AddGoodWill(int good)
        {
            this.GoodWill += good;
            Ask();
        }

        public override void DelGoodWill(int good)
        {
            this.GoodWill -= good;
            Ask();
        }

        public override void Eat()
        {
            AddGoodWill(1);
            Console.WriteLine("我们只是朋友，我不去");
            Ask();
        }

        public override void YueHui()
        {
            AddGoodWill(1);
            Console.WriteLine("我们只是朋友，我不去");
            Ask();
        }

        //询问是否有好感
        public void Ask()
        {
            if (this.GoodWill > 5)
            {
                Account.love = new Lovers();
            }
        }
    }

我们定义一个好感度机制，让他大于5才能变成恋人。小于等于5，那么每次叫出去，都不去。

任务三：创建恋人反应

我们创建一个恋人的反应。直接上代码。

public class Lovers : Love
    {
        public override void AddGoodWill(int good)
        {
            this.GoodWill += good;
            Ask();
        }

        public override void DelGoodWill(int good)
        {
            this.GoodWill -= good;
            Ask();
        }

        public override void Eat()
        {
            Console.WriteLine("我们是恋人，我去");
        }

        public override void YueHui()
        {
            Console.WriteLine("我们是恋人，我去");
        }

        //询问是否有好感
        public void Ask()
        {
            if (this.GoodWill < 5)
            {
                Account.love = new Friend(this.GoodWill, this.Account);
            }
        }
    }

这样，虽然外表没有改变，还是一个类。但是实际上，根据状态的不同，实现的东西也随之不同。

这就是状态模式。我们最后调用一下，看一下结果。

private static void Main(string[] args)
        {
            Console.WriteLine("两个人刚认识");
            Account account = new Account(0);
            Console.WriteLine("约吃饭");
            account.Eat();
            Console.WriteLine("慢慢交往，继续不停的约吃饭");
            for (int i = 0; i < 5; i++)
            {
                account.Eat();
            }
            account.Eat();
            account.YueHui();
            Console.ReadLine();
        }

总结

允许一个对象在其内部状态改变的时候，自行改变行为。让调用模块不进行修改，但是执行的确结果却是不同的。

常用场景：一个对象在多个状态下行为不同，且这些状态可相互转换。

选择关键点：这些状态是否经常在运行时需要在不同的状态下相互切换