设计模式行为型之状态模式

定义

一.状态模式的定义：状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。

二.状态模式的意图：允许一个对象在其内部状态改变时改变它的行为。

模拟场景

模拟交通灯指示灯

两个角色

 上下文环境（Context）：它定义了客户程序需要的接口并维护一个具体状态角色的实例，将与状态相关的操作委托给当前的Concrete State对象来处理。

 抽象状态（State）：定义一个接口以封装使用上下文环境的的一个特定状态相关的行为。

 具体状态（Concrete State）：实现抽象状态定义的接口。下列代码中指的是不同颜色的灯

代码实现

1.定义一个抽象类

    /// <summary>
    /// 抽象类
    /// </summary>
    public abstract class LightBase
    {
        /// <summary>
        /// 灯颜色
        /// </summary>
        public LightColor Color
        {
            get;
            set;
        }

        /// <summary>
        /// show
        /// </summary>
        public abstract void Show();

        /// <summary>
        /// 变色
        /// </summary>
        public abstract void Turn(Context context);
    }

    /// <summary>
    /// 灯颜色 定义一个枚举
    /// </summary>
    public enum LightColor
    {
        Red = 0,
        Yello = 1,
        Green = 2
    }

 

2.定义上下文对象

    /// <summary>
    /// 上下文对象
    /// </summary>
    public class Context
    {
        public LightBase CurrentLight
        {
            get;
            set;
        }

        public void Show()
        {
            this.CurrentLight.Show();
        }

        public void Turn()
        {
            this.CurrentLight.Turn(this);
        }
    }

 

3.定义三个具体子类

   /// <summary>
    /// 红灯
    /// </summary>
    public class LightRed : LightBase
    {
        public LightRed()
        {
            this.Color = LightColor.Red;
        }
        public override void Show()
        {
            Console.WriteLine("红灯停");
        }

        public override void Turn(Context context)
        {
            context.CurrentLight = new LightGreen();
        }
    }



    /// <summary>
    /// 黄灯
    /// </summary>
    public class LightYellow : LightBase
    {
        public LightYellow()
        {
            this.Color = LightColor.Yello;
        }
        public override void Show()
        {
            Console.WriteLine("黄灯亮了,等一等");
        }

        public override void Turn(Context context)
        {
            context.CurrentLight = new LightRed();
        }

    }


    /// <summary>
    /// 绿灯
    /// </summary>
    public class LightGreen : LightBase
    {
        public LightGreen()
        {
            this.Color = LightColor.Green;
        }

        public override void Show()
        {
            Console.WriteLine("绿灯行");
        }

        public override void Turn(Context context)
        {
            context.CurrentLight = new LightYellow();
        }
    }

 

上端测试代码

        static void Main(string[] args)
        {

            {
                LightBase light = new LightRed();
                Context context = new Context();
                context.CurrentLight = light;

                context.Show();
                context.Turn();
        
                context.Show();
                context.Turn();
               
                context.Show();
                context.Turn();
              
                context.Show();
                context.Turn();
            
                context.Show();
                context.Turn();

            }

 

运行结果如下：

 

总结

优点：将子类不同状态的行为分离出来，降低类之间的耦合。

缺点：复杂性，子类变多

应用场景：比如像电路开关等这样的状态变化应用