设计模式（十四）状态模式_public int hour { get { return hour; } set { hour -CSDN博客

本文链接：https://blog.csdn.net/qq_36770641/article/details/82886998

不同的时间，工作状态不同。代码实现？

工作类：

public class Work {
    private int hour;
    public int Hour{
        get{return hour;}
        set{hour=value;}
    }
    private bool finish = false;
    public bool TaskFinished{
        get{return finish;}
        set{finish=value;}
    }
    public void WritrProgram(){
        if(hour<12){
            Console.WriteLine("当前时间：{0}点 上午工作，精神百倍",hour);
        }
        else if(hour<13){
            Console.WriteLine("当前时间：{0}点 饿了，午饭；犯困，午休。",hour);
        }
        else if(hour<17){
            Console.WriteLine("当前时间：{0}点 下午状态还不错，继续努力",hour);
        }
        else{
            if(finish){
                Console.WriteLine("当前时间：{0}点 下班回家了",hour);
            }
            else{
                if(hour<21){
                    Console.WriteLine("当前时间：{0}点 加班哦，疲惫至极",hour);
                }
                else{
                    Console.WriteLine("当前时间：{0}点 不行了，睡着了",hour);
                }
            }
        }    
    }
}

客户端程序如下：

结果表现如下：

来看一下我们写的代码。会发现方法很长，而且有很多的判断分支，这也就意味着它的责任过大了。无论是任何状态，都需要通过它来改变，这实际上是很糟糕的。

面向对象设计其实就是希望做到代码的责任分解。这个类违背了“单一职责原则”。由于WriteProgram（写程序）的方法里有这么多判断，使得任何需求的改动或增加都需要去更改这个方法了。

状态模式

状态模式（State），当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

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

State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为：

abstract class State{
    public abstract void Handle(Context context);
}

ConcreteState类，具体状态，每一个子类实现一个与Context的一个状态相关的行为：

class ConcreteStateA : State{
    public override void Handle(Context context){
        // 设置ConcreteStateA的下一状态是ConcreteStateB
        context.State = new ConcreteStateB();
    }
}

class ConcreteStateB : State{
    public override void Handle(Context context){
        // 设置ConcreteStateB的下一状态是ConcreteStateA
        context.State = new ConcreteStateA();
    }
}

Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态：

class Context{
    private State state;
    // 定义Context的初始状态
    public Context (State state){
        this.state=state;
    }
    
    // 可读写的状态属性，用于读取当前状态和设置新状态
    public State State{
        get{return state;}
        set{
            state = value;
            Console.WriteLine("当前状态：" + state.GetType().Name);
        }
    }

    public void Request(){
        // 对请求作处理，并设置下一状态
        state.Handle(this);
    }
}

客户端代码：

static void Main(string[] args){
    // 设置Context的初始状态为ConcreteStateA
    Context c = new Context (new ConcreteState());

    // 不断的请求，同时更改状态
    c.Request();
    c.Request();
    c.Request();  
    c.Request();

    Console.Read();
}

状态模式的好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。

将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类可以很容易地增加新的状态和转换。

状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。

当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。

工作状态－状态模式版

代码结构图：

抽象状态类，定义一个抽象方法“写程序”：

// 抽象状态 
public abstract class State{
    public abstract void WriteProgram(Work w);
}

上午和中午工作状态类：

// 上午工作状态
public class ForenoonState : State{
    public override void WriteProgram(Work w){
        if(w.Hour<12){
            Console.WriteLine("当前时间：{0}点 上午工作，精神百倍", w.Hour);
        }
        else{
            // 超过12点，则转入中午工作状态
            w.SetState(new NoonState());w.WriteProgram();
        }
    }
}


// 中午工作状态
public class NoonState : State{
    public override void WriteProgram(Work w){
        if(w.Hour<13){
            Console.WriteLine("当前时间：{0}点 饿了，午饭；犯困，午休。", w.Hour);
        }
        else{
            // 超过13点，则转入下午工作状态
            w.SetState(new NoonState());w.WriteProgram();
        }
    }
}

下午和傍晚工作状态类：

// 下午工作状态
public class AfternoonState : State{
    public override void WriteProgram(Work w){
        if(w.Hour<12){
            Console.WriteLine("当前时间：{0}点 下午状态还不错，继续努力", w.Hour);
        }
        else{
            // 超过17点，则转入傍晚工作状态
            w.SetState(new EveningState());
            w.WriteProgram();
        }
    }
}


// 晚间工作状态
public class EveningState : State{
    public override void WriteProgram(Work w){
        if(w.TaskFinished){
            // 如果完成任务，则转入下班状态
            w.SetState(new RestState());
            w.WriteProgram();
        }
        else{
            if(w.Hour<21){
                Console.WriteLine("当前时间：{0}点 加班", w.Hour);
                }
            else{
                // 超过21点，则转入睡眠工作状态
                w.SetState(new EveningState());
                w.WriteProgram();
            } 
        }
    }
}

睡眠状态和下班休息状态类：

// 睡眠状态
public class SleepingState : State{
    public override void WriteProgram(Work w){
        Console.WriteLine("当前时间：{0}点不行了，睡着了。",w.Hour);
    }
}


// 下班休息状态
public class RestState :State{
    public override void WriteProgram(Work w){
        Console.WriteLine("当前时间：{0}点下班回家了",w.Hour);
    }
}

工作类，此时没有了过长的分支判断语句：

// 工作
public class Work{
    private State current;
    public Work(){
        // 工作初始化为上午工作状态，即上午9点开始上班
        current = new ForenoonSate();
    }

    private double hour;
    // “钟点”属性，状态转换的依据
    public double Hour{
        get{return hour;}
        set{hour=value;}
    }

    private bool finish = false;
    public bool TaskFinished{
        get{return finish;}
        set{finish=value;}
    }

    public void SetState(State s){
        current=s;
    }

    public void WriteProgram(){
        current.WriteProgram(this);
    }
}

客户端代码没有任何改动，但我们的程序却更加灵活易变了。