设计模式之行为型模式

行为型模式

策略模式

策略模式：算法分别封装起来，相互间可以替换，从而算法的变化不影响使用算法的客户；
例子：设计一个商场收银软件，营业员根据客户购买商品的单价和数量收费；

//抽象算法类
abstract class Strategy
{
    //算法方法
    public abstract void AlgorithmInterface();
}

class ConcreteStrategyA:Strategy
{
    //算法A实现方法
    public override void AlgorithmInterface()
    {
        Console.WriteLine("算法A实现");
    }
}
//具体算法B
class ConcreteStrategyB:Strategy
{
    //算法B实现方法
    public override void AlgorithmInterface()
    {
        Console.WirteLine("算法B实现")
    }
}
//具体算法C
class ConcreteStrategyC:Strategy
{
    //算法C实现方法
    public override void AlgorithmInterface()
    {
        Concole.WriteLine("算法C实现");
    }
}

//上下文
class Context
{
    Strategy strategy;
    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }
    //上下文接口
    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}

//客户端代码
static void Main(string[] args)
{
    Context context;
    context = new Context(new ConcreteStrategyA());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyB());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyC());
    context.ContextInterface();

    Console.Read();
}

策略模式是一种定义算法的方法；用来封装算法；

---

观察者模式

观察者模式：定义一种一对多的依赖关系，多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，通知所有观察者对象，能够自动更新自己；
例子：前台小姐监听老板，给同事炒股票打掩护；

应用：
一个对象的改变需要同时改变其他对象的时候，不知道具体有多少对象改变的时候；

---

状态模式

状态模式：一个对象的内在状态改变时允许改变其行为；这个对象看起来是像改变了其类；
例子：不同时刻有不同的状态，上午状态好，中午犯困，下午逐渐恢复，加班煎熬；

State类
abstract class State
{
    public abstract void Handle(Context context);
}
ConcreteState类
class ConcreteStateA:state   //设置ConcreteStateA的下一个状态是ConcreteStateB
{
    public override void Handle(Context context)
    {
        context.State = new ConcreteStateB();
    }
}
class ConcreteStateB:State    //设置ConcreteStateB的下一个状态是ConcreteStateA
{
    public override void Handle(Context context)
    {
        context.State = new ConcreteStateA();
    }
}
Context类
class Context
{
    private State state;
    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 c = new Context(new ConcreteStateA());    //设置Context的初始状态为ConcreteStateA

    c.Request();
    c.Request();
    c.Request();
    c.Request();

    Console.Read();
}

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

---

备忘录模式

备忘录模式：不破坏封装性前提下，捕获一个对象的内部状态，在该对象之外保存这个状态，可以将该对象恢复到原先保存的状态；
例子：单机PC游戏打大Boss前，先保存一个游戏进度，这样即使通关失败，也可以返回之前的游戏进度来重新打大Boss；

创建、存储、保存；

发起人(Originator)类
class Originator
{
    private string state;
    public string State    //需要保存的属性，可能有多个
    {
        get { return state; }
        set { state = value; }
    }
    public Memento CreteMemento()    //创建备忘录，将当前需要保存的信息导入并实例化一个Memento对象
    {
        return (new Memento(state));
    }
    public void SetMemento(Memento memento)    //恢复备忘录，将Memento导入并将相关数据恢复
    {
        state = memento.State;
    }
    public void Show()    //显示数据
    {
        Console.WriteLine("State=" + state);
    }
}

备忘录(Memento)类
class Memento
{
    private string state;

    public Memento(string state)
    {
        this.state = state;
    }
    public string State
    {
        get {return state; }
    }
}
管理者(Caretaker)类
class Caretaker
{
    private Memento memento;

    public Memento Memento
    {
        get { return memento; }
        set { memento = value; }
    }
}
客户端程序
static void Main(string[] args)
{
    Originator p = new Originator();    //Originator初始状态，状态属性为"On"；
    o.State = "On";
    o.Show();

    Caretaker c = new Cartaker();
    c.Memento = o.CreateMemento();

    o.State = "Off";
    o.Show();

    o.SetMemento(c.Memento);    //恢复初始状态
    o.Show();

    Console.Read();
}

---

迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，不暴露该对象的内部表示；
例子：售票员将车厢内所有人遍历一遍，不放过任何一个没有买票的人；

Iterator 迭代器抽象类
abstract class Iterator
{
    public abstract object First();
    public abstract object Next();
    public abstract bool IsDone();
    public abstract object CurrentItem();
}
Aggregate聚集抽象类
absract class Aggregate
{
    public abstract Iterator CreateIterator();
}
ConcreteIterator具体迭代器类，继承Iterator
class ConcreteIterator :Iterator
{
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate aggregate)
    {
        this.aggregate = aggregate;
    }
    public override object First()
    {
        return aggregate[0];
    }
    public override object Next()
    {
        object ret = null;
        current++;
        if (current < aggregate.Count)
        {
            ret = aggregate[current];
        }
        return ret;
    }

    public override bool = IsDone()
    {
        return current >= aggregate.Count ? true :false;
    }

    public override object CurrentItem()
    {
        return aggregate[current];
    }
}

...

应用：访问一个聚集对象，不管这些对象是什么都需要遍历时；聚集有多种方式遍历时；

---

命令模式

例子：烧烤摊和烧烤店的对比，烧烤店服务员做记录，同时可以撤销请求，可以对请求进行修改；
命令模式：将请求封装为对象，可用不同请求对客户参数化，对请求做记录，排序、支持可撤销等操作；

---

职责连模式

职责链模式：多个对象都有机会处理请求，从而避免发送者和接收者间的耦合关系，将该对象连成一条链，沿着这条链传递请求，直到有一个对象处理为止；
例子：小菜申请加薪需要通过层层递进；

---

中介者模式

中介者模式：用一个中介对象来封装系列的对象交互。
例子：联合国组织协调各国间的矛盾，起着一个中介者的作用；

中介者特点：
Mediator减少各个Colleague的耦合，可以独立的改变和复用各个Colleague类；
缺点是集中化，交互复杂性变成了中介者的复杂性；

---

解释器模式

解释器模式：给定一个语言，定义文法的一种表示，定义一个解释器，这个解释器使用该表示来解释语言中的句子；
例子：读懂老板的心思；
音乐解释器为例：

特点：容易改变和扩展文法；

---

访问者模式

访问者模式：一个作用于某对象结构中各元素的操作，可以使得在不改变各元素的类前提下定义作用于这些元素的新操作；

访问者模式适用于数据结构相对稳定的系统；适用于较稳定的数据结构和易于变化的算法；
特点：容易增加新的操作；

---

最后还有一个模板方法模式：

模板方法模式

模板方法模式：定义一个操作中算法骨架，将步骤延迟到子类中，子类可以不改变算法结构从而重定义算法某些特定步骤；
例子：数学老师的随堂测试，题目抄错了，会做也白搭；

特点：
模板方法去除子类重复代码；不变的和可变的行为在方法的子类实现中混合在一起，模板方法模式将不变行为移到单一的地方；
一种继承和多态的充分应用；

---