行为型---状态者模式（State Pattern）

状态者模式的介绍

　　每个对象都有其对应的状态，而每个状态又对应一些相应的行为，如果某个对象有多个状态时，那么就会对应很多的行为。那么对这些状态的判断和根据状态完成的行为，就会导致多重条件语句，并且如果添加一种新的状态时，需要更改之前现有的代码。这样的设计显然违背了开闭原则。状态模式正是用来解决这样的问题的。状态模式将每种状态对应的行为抽象出来成为单独新的对象，这样状态的变化不再依赖于对象内部的行为。

状态者模式的定义

　　上面对状态模式做了一个简单的介绍，这里给出状态模式的定义。

　　状态模式——允许一个对象在其内部状态改变时自动改变其行为，对象看起来就像是改变了它的类。

状态者模式的结构

　　既然状态者模式是对已有对象的状态进行抽象，则自然就有抽象状态者类和具体状态者类，而原来已有对象需要保存抽象状态者类的引用，通过调用抽象状态者的行为来改变已有对象的行为。经过上面的分析，状态者模式的结构图也就很容易理解了，具体结构图如下图示。

• State----抽象状态角色

          接口或抽象类,负责对象状态定义,并且封装环境角色以实现状态切换。 

• ConcreteState----具体状态角色

          本状态的行为管理以及趋向状态处理,通俗地说,就是本状态下要做的事情,以及本状态如何过渡到其他状态。 

• Context----环境角色

          定义客户端需要的接口,并且负责具体状态的切换。

 

    环境角色有两个不成文的约束:    

• 把状态对象声明为静态常量,有几个状态对象就声明几个静态常量。
• 环境角色具有状态抽象角色定义的所有行为,具体执行使用委托方式。

 

具体代码实现:

namespace ConsoleApplication1

{

    /// <summary>

    /// 抽象状态角色

    /// </summary>

    public abstract class State

    {

        //定义一个环境角色,提供子类访问

        protected Context context;

        public Context Context

        {

            set { context = value; }

        }

        //行为1

        public abstract void handle1();

        //行为2

        public abstract void handle2();

    }

    /// <summary>

    /// 具体状态角色

    /// </summary>

    public class ConcreteState1 : State

    {

        public override void handle1()

        {

            //本状态下必须处理的逻辑

        }

        public override void handle2()

        {

            //设置当前状态为state2

            context.CurrentState = Context.STATE2;

            //过渡到state2状态,由Context实现

            context.handle2();

        }

    }

    /// <summary>

    /// 具体状态角色

    /// </summary>

    public class ConcreteState2 : State

    {

        public override void handle1()

        {

            //设置当前状态为state1

            context.CurrentState = Context.STATE1;

            //过渡到state1状态,由Context实现

            context.handle1();

        }

        public override void handle2()

        {

            //本状态下必须处理的逻辑

        }

    }

    /// <summary>

    /// 具体环境角色

    /// </summary>

    public class Context

    {

        //定义状态

        public static State STATE1 = new ConcreteState1();

        public static State STATE2 = new ConcreteState2();

        //当前状态

        private State currentState;

        public State CurrentState

        {

            get

            {

                //获取当前状态

                return currentState;

            }

            set

            {

                //设置当前状态

                currentState=value;

                currentState.Context=this;

            }

        }

        //行为委托

        public void handle1()

        {

            currentState.handle1();

        }

        public void handle2()

        {

            currentState.handle2();

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            //定义环境角色

            Context context = new Context();

            //初始化状态

            context.CurrentState = new ConcreteState1();

            //行为执行

            context.handle1();

            context.handle2();

            Console.ReadLine();

        }

    }

}

状态者模式的优缺点

　　状态者模式的主要优点是：

• 结构清晰

          避免了过多的switch...case或者if...else语句使用,避免了程序的复杂性,提高系统的可维护性。 

• 遵循设计原则

          很好的体现了开闭原则和单一职责原则,每个状态都是一个子类,你要增加状态就要增加子类,你要修改状态,你只修改一个子类就可以了。 

• 封装性非常好

          状态变换放置到类的内部来实现,外部的调用不用知道类内部如何实现状态和行为的变换。

 

　　状态者模式的主要缺点是：

• 子类会太多,也就是类膨胀。

状态者模式的应用场景

　　在以下情况下可以考虑使用状态者模式。

• 行为随状态改变而改变的场景

• 条件、分组判断语句的替代者

          在程序中大量使用switch语句或者if判断语句会导致程序结构不清晰,逻辑混乱,使用状态模式可以很好地避免这一问题,它通过扩展子类 实现了条件的判断处理。

应用一:

用状态模式来模拟一个电梯的状态场景:

具体代码实现:

namespace ConsoleApplication1

{

    /// <summary>

    /// 抽象电梯状态

    /// </summary>

    public abstract class LiftState

    {

        protected Context context;

        public Context Context

        {

            set { context = value; }

        }

        //首先电梯们开启动作

        public abstract void open();

        //电梯们有开启,那当然也就有关闭了

        public abstract void close();

        //电梯要能上能下,运行起来

        public abstract void run();

        //电梯还要能停下来

        public abstract void stop();

    }

    /// <summary>

    /// 敞门状态

    /// </summary>

    public class OpenningState : LiftState

    {

        //打开电梯门

        public override void open()

        {

            Console.WriteLine("电梯门开启...");

        }

        public override void close()

        {

            context.LiftState = Context.closeingState;

            context.LiftState.close();

        }

        public override void run()

        {

        }

        public override void stop()

        {

        }

    }

    /// <summary>

    /// 关闭状态

    /// </summary>

    public class CloseingState : LiftState

    {

        //电梯门关了再打开

        public override void open()

        {

            //设置为敞门状态

            context.LiftState = Context.openningState;

            context.LiftState.open();

        }

        //电梯门关闭,这是关闭状态要实现的动作

        public override void close()

        {

            Console.WriteLine("电梯门关闭...");

        }

        //电梯门关了就运行

        public override void run()

        {

            //设置为运行状态

            context.LiftState = Context.runingState;

            context.LiftState.run();

        }

        //电梯门关着

        public override void stop()

        {

            //设置为停止状态

            context.LiftState = Context.stoppingState;

            context.LiftState.stop();

        }

    }

    /// <summary>

    /// 运行状态

    /// </summary>

    public class RunningSate : LiftState

    {

        public override void open()

        {

        }

        public override void close()

        {

        }

        public override void run()

        {

            Console.WriteLine("电梯上下运行...");

        }

        public override void stop()

        {

            //设置为停止状态

            context.LiftState = Context.stoppingState;

            context.LiftState.stop();

        }

    }

    /// <summary>

    /// 停止状态

    /// </summary>

    public class StoppingState : LiftState

    {

        public override void open()

        {

            //设置为敞门状态

            context.LiftState = Context.openningState;

            context.LiftState.open();

        }

        public override void close()

        {

        }

        public override void run()

        {

            //设置为运行状态

            context.LiftState = Context.runingState;

            context.LiftState.run();

        }

        public override void stop()

        {

            Console.WriteLine("电梯停止了...");

        }

    }

    /// <summary>

    /// 上下文类

    /// </summary>

    public class Context

    {

        //定义出所有的电梯状态

        public static OpenningState openningState = new OpenningState();

        public static CloseingState closeingState = new CloseingState();

        public static RunningSate runingState = new RunningSate();

        public static StoppingState stoppingState = new StoppingState();

        //定义一个当前电梯状态

        private LiftState liftState;

        public LiftState LiftState

        {

            get

            {

                return liftState;

            }

            set

            {

                liftState = value;

                //把当前的环境通知到各个实现类中

                liftState.Context = this;

            }

        }

        public void open()

        {

            liftState.open();

        }

        public void close()

        {

            liftState.close();

        }

        public void run()

        {

            liftState.run();

        }

        public void stop()

        {

            liftState.stop();

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            Context context = new Context();

            context.LiftState = new CloseingState();

            context.open();

            context.close();

            context.run();

            context.stop();

            Console.ReadLine();

        }

    }

}

应用二:

下面，就以银行账户的状态来实现下状态者模式。银行账户根据余额可分为RedState、SilverState和GoldState。这些状态分别代表透支账号，新开账户和标准账户。账号余额在【-100.0，0.0】范围表示处于RedState状态，账号余额在【0.0 ， 1000.0】范围表示处于SilverState，账号在【1000.0， 100000.0】范围表示处于GoldState状态。下面以这样的一个场景实现下状态者模式，具体实现代码如下所示：

namespace ConsoleApplication1

{

    /// <summary>

    /// 抽象存款状态

    /// </summary>

    public abstract class State

    {

        protected Account context;

        public Account Context

        {

            set { context = value; }

        }

        /// <summary>

        /// 余额

        /// </summary

        public double Balance { get; set; }

        /// <summary>

        /// 利率

        /// </summary>

        public double Interest { get; set; }

        /// <summary>

        /// 下限

        /// </summary>

        public double LowerLimit { get; set; }

        /// <summary>

        /// 上限

        /// </summary>

        public double UpperLimit { get; set; }

        public abstract void Deposit(double amount); // 存款

        public abstract void Withdraw(double amount); // 取钱

        public abstract void PayInterest(); // 获得的利息

        public void Display(string OperationType, double amount)

        {

            switch (OperationType)

            {

                case "Deposit":

                    Console.WriteLine("存款金额为 {0:C}——", amount);

                    Console.WriteLine("账户余额为 =:{0:C}", this.Balance);

                    Console.WriteLine("账户状态为: {0}", this.GetType().Name);

                    Console.WriteLine();

                    break;

                case "Withdraw":

                    Console.WriteLine("取款金额为 {0:C}——", amount);

                    Console.WriteLine("账户余额为 =:{0:C}", this.Balance);

                    Console.WriteLine("账户状态为: {0}", this.GetType().Name);

                    Console.WriteLine();

                    break;

                case "PayInterest":

                    Console.WriteLine("Interest Paid --- ");

                    Console.WriteLine("账户余额为 =:{0:C}", this.Balance);

                    Console.WriteLine("账户状态为: {0}", this.GetType().Name);

                    Console.WriteLine();

                    break;

                default:

                    break;

            }

        }

    }

    /// <summary>

    /// Red State意味着Account透支

    /// </summary>

    public class RedState : State

    {

        public RedState()

        {

            Interest = 0.00;

            LowerLimit = -100.00;

            UpperLimit = 0.00;

        }

        public RedState(double balance)

            :this()

        {

            this.Balance = balance;

        }

        // 存款

        public override void Deposit(double amount)

        {

            Balance += amount;

            if (Balance > UpperLimit)

            {

                context.AccountState = new SilverState(this.Balance); //Context.silverState;

            }

        }

        // 取钱

        public override void Withdraw(double amount)

        {

            Console.WriteLine("没有钱可以取了！");

        }

        public override void PayInterest()

        {

            // 没有利息

        }

    }

    /// <summary>

    /// Silver State意味着没有利息得

    /// </summary>

    public class SilverState : State

    {

        public SilverState()

        {

            Interest = 0.00;

            LowerLimit = 0.00;

            UpperLimit = 1000.00;

        }

        public SilverState(double balance)

            :this()

        {

            this.Balance = balance;

        }

        public override void Deposit(double amount)

        {

            Balance += amount;

            StateChangeCheck();

        }

        public override void Withdraw(double amount)

        {

            Balance -= amount;

            StateChangeCheck();

        }

        public override void PayInterest()

        {

            Balance += Interest * Balance;

            StateChangeCheck();

        }

        private void StateChangeCheck()

        {

            if (Balance < LowerLimit)

            {

                context.AccountState = new RedState(this.Balance);//Context.redState;

            }

            else if (Balance > UpperLimit)

            {

                context.AccountState = new GoldState(this.Balance);//Context.goldState;

            }

        }

    }

    /// <summary>

    /// Gold State意味着有利息状态

    /// </summary>

    public class GoldState : State

    {

        public GoldState()

        {

            Interest = 0.05;

            LowerLimit = 1000.00;

            UpperLimit = 1000000.00;

        }

        public GoldState(double balance)

            :this()

        {

            this.Balance = balance;

        }

        public override void Deposit(double amount)

        {

            Balance += amount;

            StateChangeCheck();

        }

        public override void Withdraw(double amount)

        {

            Balance -= amount;

            StateChangeCheck();

        }

        public override void PayInterest()

        {

            Balance += Interest * Balance;

            StateChangeCheck();

        }

        private void StateChangeCheck()

        {

            if (Balance < 0.0)

            {

                context.AccountState = new RedState(this.Balance);//Context.redState;

            }

            else if (Balance < LowerLimit)

            {

                context.AccountState = new SilverState(this.Balance);//Context.silverState;

            }

        }

    }

    /// <summary>

    /// 上下文类

    /// </summary>

    public class Account

    {

        //定义出所有的存款账户状态

        //public static RedState redState = new RedState();

        //public static SilverState silverState = new SilverState();

        //public static GoldState goldState = new GoldState();

        //定义一个当前存款账户状态

        private State accountState;

        public State AccountState

        {

            get

            {

                return accountState;

            }

            set

            {

                accountState = value;

                //把当前的环境通知到各个实现类中

                accountState.Context = this;

            }

        }

        public void Deposit(double amount)

        {

            accountState.Deposit(amount);

            accountState.Display("Deposit", amount);

        }

        public void Withdraw(double amount)

        {

            accountState.Withdraw(amount);

            accountState.Display("Withdraw", amount);

        }

        public void PayInterest()

        {

            accountState.PayInterest();

            accountState.Display("PayInterest", );

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            Account account = new Account();

            account.AccountState = new SilverState(0.0);

            // 进行交易

            // 存钱

            account.Deposit(1000.0);

            account.Deposit(200.0);

            account.Deposit(600.0);

            // 付利息

            account.PayInterest();

            // 取钱

            account.Withdraw(2000.00);

            account.Withdraw(500.00);

            Console.ReadLine();

        }

    }

}