设计模式-行为型

LeafElement  叶子元素

+Accept(visitor: Visitor): void+Operation(): string

AbstractClass 抽象类

+TemplateMethod(): void+SpecificMethod(): void+Method1(): void+Method2(): void+HookMethod1(): void+HookMethod2(): bool

ConcreteClassB

具体子类

+Method1(): void+Method2(): void

ConcreteColleague2

-mediator: Mediator

+Receive(message: string): void+Send(message: string): void

ConcreteElementB

+Accept(visitor: Visitor): void+OperationB(): string

// 抽象同事类设置中介者public void SetMediator(Mediator mediator){    this.mediator = mediator;}// 具体同事类接收消息public override void Receive(string message){    Console.WriteLine(\"具体同事类1收到请求：\" + message)}// 具体同事类发送消息public override void Send(string message){    Console.WriteLine(\"具体同事类1发出请求：\

Caretaker 管理者

-memento: Memento

+SetMemeto(m: Memento): void+GetMemento(): Memento

备忘录模式与原型模式混合使用

RedirectCommand

+OnExecute(HttpContext context)

public void Call(string s){    command.Execute(s);}

StrategyFactory 策略工厂

Person 复杂数据类型

+ name: string+ mobile: string

// 由调用者 Client 来灵活配置链条结构Handler handler1 = new ConcreteHandler1();Handler handler2 = new ConcreteHandler2();Handler handler3 = new ConcreteHandler3();handler1.SetNext(handler2);handler2.SetNext(handler3);//提交请求 handler1.HandleRequest(new LeaveRequest(\"Tom\

InsertionSort

+sort(in array): array

//同事类不持有中介者，需要时直接获取中介者对象并调用public ConcreteColleague1(){   SimpleMediator.GetMediator().Register(this);}

ArrayHandler

-sortObj: Sort

+setSort(Sort sort)+sort(in array): array

Notify():foreach(var o in observers){    o.Response(); }

状态模式

Sort

模板方法模式在抽象类中定义一个操作的算法骨架，而将一些具体步骤的实现延迟到子类实现，使得子类在不改变算法结构的前提下，重新定义算法的特定步骤，从而也达到代码复用的效果。抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架，它由一个模板方法和若干个基本方法构成。具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。.NET中模板方法的应用：例如开发自定义的Web控件或WinForm控件时，只需要重写某个控件的部分方法。

<<interface>>Iterator 抽象迭代器

+HasNext(): bool+First(): Object+Next(): Object+Reset(): void+GetCurrent(): Object

+TemplateMethod(): void+SpecificMethod(): void+Method1(): void+Method2(): void

ConcreteHandler1

-next: Handler

树叶构件: 具体命令A

Client 访问者

+ Operation(): void

IVisitor 抽象访问者

+Visit(element: LeafElement): void+Visit(element: CompositeElement): void

策略模式

命令模式命令模式属于对象行为模式，把一个请求或操作封装成一个对象，通过对命令的抽象化来使得命令的发送者和接收者解耦，两者之间没有直接联系，同时该模式还支持可撤销和可恢复的操作。抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。具体命令角色（Concrete Command）角色：抽象命令类的具体实现类，拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。调用者/请求者（Invoker）角色：请求的发送者，通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，不直接访问接收者。客户角色（Client）：创建具体的命令对象，并且设置命令对象的接收者。

<<interface>>IColleague  抽象同事接口

观察者模式定义了对象之间的一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当被监听的主题对象的状态发生变化时，会通知所有观察者对象，使得他们能够自动更新自己的行为。抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

ConcreteSubject

-subjectState

+Notify(): void

ConcreteClassA

SimpleMediator  简单单例中介者

-smd: SimpleMediator-colleagues: List<IColleague>

ConcreteStrategyA

具体策略

+Algorithm(): void

Client 访问类

+Operation(): void

<<interface>>ICommand 抽象命令

+Execute(s: string): void

ShareState 抽象状态类

+Handle(c: ShareContext): void

CompositeReceiver

接收者

+Action1(s: string): void+Action2(s: string): void

//定义环境类的初始状态public ShareContext(){    state = new ConcreteState1();    stateDic.Add(\"1\

ConcreteColleague1

<<interface>>IAggregate 抽象聚合

+Add(obj: Object): void+Remove(obj: Object): void+GetIterator(): Iterator

+nexter: Handler

+HandlerRequest(request: string): bool

中介者模式定义一个中介对象来封装一系列对象之间的交互关系，使得各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立改变它们之间的交互行为。中介者的作用：结构上中转，行为上协作。封装了对象关系，减少耦合，使对象间可独立改变和复用。抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

ReceiverA 接收者

+Action(s: string): void

解释器模式定义一种语言的语法，并建立一个解释器来解释该语言中的句子。解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。

ConcreteCommandA

-receiver: CompositeReceiver

FirstPortal

Invoker  调用者

-command: ICommand

+Invoker(command: ICommand)+SetCommand(command: ICommand): void+Call(s: string): void

Client

访问类

<<Interface>>System.Web.UI.IHttpHandler

+ProcessRequest(HttpContext context)

Colleague 抽象同事类

+SetMediator(mediator: Mediator): void+Receive(message: string): void+Send(message: string): void

BubbleSort

客户端设置责任链示例

+Method1(): void+Method2(): void+HookMethod1(): void+HookMethod2(): bool

ConcreteStrategyB

-receiver: ReceiverA

中介者模式

<<Interface>>Command

+Execute(HttpContext context)

next

备忘录模式

ConcreteVisitorB 具体访问者

ConcreteState1 具体状态

+Handle(c: Context): void

ConcreteHandler3

SecondPortal

Client 访问类

public void Execute(string s){    receiver.Action1(s);}

Originator  发起人

-state: Person

+GetState(): Person+RestoreMemento(m: Memeto): void+CreateMemeto(): Memeto

IAggregate ag = new ConcreteAggregate();IIterator it = ag.GetIterator(); while (it.HasNext()) { // TODO }

设计模式之行为型模式行为型模式主要描述类或对象之间是怎么交互和分配职责的，涉及到算法和对象间的职责分配，以及通信方式。分为类模式和对象模式两种，类模式：使用继承关系在几个类之间的分配行为；对象模式：使用对象聚合的方式来分配行为。1，观察者模式定义了对象之间的一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当被监听的主题对象的状态发生变化时，会通知所有观察者对象，使得他们能够自动更新自己的行为。2，策略模式将每个算法封装到不同的策略类中，使得它们可以互换。是对算法的封装，把使用算法的职责和算法本身分离，委派给不同的对象负责。3，迭代器模式提供一种方法来顺序访问一个集合对象中的元素，而无需暴露其内部的结构。4，中介者模式定义一个中介对象来封装一系列对象之间的交互关系，使得各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立改变它们之间的交互行为。5，模板方法模式在抽象类中定义一个操作的算法骨架，而将一些具体步骤的实现延迟到子类实现，使得子类在不改变算法结构的前提下，重新定义算法的特定步骤，从而也达到代码复用的效果。6，职责链模式将处理某一种事物的对象组成一条链，发送者将请求发给链的第一个接收者，并沿着链传递，直到有一个对象来处理它或者直到最后也没有对象处理而留在最末端。将请求发送者和接收者解耦，简化对象的结构，每个对象只需引用后继者即可，不必了解整个链条，提高系统灵活性，使得增加新的请求处理类也比较方便。7，命令模式命令模式属于对象行为模式，把一个请求或操作封装成一个对象，通过对命令的抽象化来使得命令的发送者和接收者解耦，两者之间没有直接联系，同时该模式还支持可撤销和可恢复的操作。8，备忘录模式在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，便于将该对象恢复到原先的状态，它实现了对信息的封装，使用者不需要关心状态保存的细节。9，状态模式允许一个对象在其内部状态改变时，自动改变其行为，对象看起来就像是改变了它的类。该模式减少大块的 if...else 判断语句，允许状态转换逻辑与状态对象合为一体。缺点是增加系统中类或对象的个数。10，访问者模式访问者模式即表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。适用于数据结构相对稳定的系统， 它把数据结构和作用于数据结构之上的操作之间的耦合度降低，使得操作集合可以相对自由地改变。11，解释器模式定义一种语言的语法，并建立一个解释器来解释该语言中的句子。解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。

观察者模式

ConcreteCommandB

-receiver: ReceiverB

<<interface>>IComponent 抽象组合类

public void Execute(string s){    receiver.Action2(s);}

public override void Handle(Context context){    Console.WriteLine(\"当前状态是 1.\");    context.SetState(new ConcreteState2());}

public void Execute(string s){    receiver.Action(s);}

具体同事类

+ConcreteColleague1()+Receive(message: string): void+Send(message: string): void

<<interface>>IStrategy 抽象策略

CommandFactory

+Maker(): Command

CompositeElement 组合元素

-list: List<IElement>

+Accept(visitor: Visitor): void+Operation(): string+Add(element: IElement): void+Remove(element: IElement): void+GetChild(i: int): IElement

CompositeInvoker  调用者

-children: List<ICommand>

+Add(c: ICommand): void+Remove(c: ICommand): void+GetChild(i int): ICommand+Execute(s: string): void

ConcreteHandler2

迭代器模式

//模板方法，定义了算法骨架public void TemplateMethod(){    Method1();    HookMethod1();    if(HookMethod2())    {        SpecificMethod();       }     Method2();}  

克隆和收藏的同学，请帮忙点个赞哈，感谢！

ConcreteIterator 具体迭代器

-list: List<Object> = null-index: int = -1

+ConcreteIterator(list: List<Object>)+HasNext(): bool+First(): Object+Next(): Object+Reset(): void+GetCurrent(): Object

UrlMap

return new ConcreteIterator(list);

-list: List<IComponent> = null-index: int = -1

+ConcreteIterator(list: List<IComponent>)+HasNext(): bool+First(): Object+Next(): Object+Reset(): void+GetCurrent(): Object

IElement 抽象元素

+Accept(visitor: IVisitor): void

ReceiverB 接收者

ConcreteState2 具体状态

命令模式

OriginatorPrototype  发起人

-state: string

+GetState(): string+SetState(s: string): void+RestoreMemento(opt: OriginatorPrototype): void+CreateMemeto(): OriginatorPrototype+Clone(): Object

状态模式允许一个对象在其内部状态改变时，自动改变其行为，对象看起来就像是改变了它的类。该模式减少大块的 if...else 判断语句，允许状态转换逻辑与状态对象合为一体。缺点是增加系统中类或对象的个数。环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为，状态之间可以互相转换。具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且根据需要进行状态切换。用于处理来自Context的请求，每一个ConcreteState都提供了它对自己请求的实现，当Context改变状态时行为也会跟着改变。

//定义环境类的初始状态public Context(){ this.state = new ConcreteStateA();}// 环境类对请求做处理public void Handle(){    state.Handle(this);}

ConcreteVisitorA 具体访问者

+Visit(element: ConcreteElementA): void+Visit(element: ConcreteElementB): void

// 树枝构件: 调用者public void Execute(string s){    foreach (var child in children)    {        child.Execute(s);       }        }    

职责链模式将处理某一种事物的对象组成一条链，发送者将请求发给链的第一个接收者，并沿着链传递，直到有一个对象来处理它或者直到最后也没有对象处理而留在最末端。将请求发送者和接收者解耦，简化对象的结构，每个对象只需引用后继者即可，不必了解整个链条，提高系统灵活性，使得增加新的请求处理类也比较方便。抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

Algorithm(string key){  strategyDic[key].Algorithm();}

Leaf 叶子节点类

Context  环境角色

-strategy: IStrategy

+GetStrategy(): IStrategy+SetStrategy(s: IStrategy): void+Algorithm(): void

备忘录模式在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，便于将该对象恢复到原先的状态，它实现了对信息的封装，使用者不需要关心状态保存的细节。发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。

ConcreteObserver1

-observerState

+Response(): void

ShareContext 享元环境类

+ShareContext()+SetState(s: ShareState): void+GetState(): ShareState+Handle(): void

<<interface>>IObserver  抽象观察者

ConcreteElementA

+Accept(visitor: Visitor): void+OperationA(): string

树叶构件: 具体命令B

迭代器模式与组合模式结合

访问者模式

-handler: Handler

模板方法模式

NonterminalExpression非终结符表达式类

-exp1: IAbstractExpression-exp2: IAbstractExpression

+Interpret(info: string): Object

Memento 备忘录

+Memento(state: Person)+GetState(): Person+SetState(state: Person): void

Composite 组合节点类

-list: List<IComponent>

+Add(obj: IComponent): void+Remove(obj: IComponent): void+GetChild(i: int): IComponent+Operation(): void+GetIterator(): Iterator

+Accept(visitor: IVisitor): void+Operation(): string

ObjectStructure 对象结构角色

+Accept(visitor: IVisitor): void+Add(element: IElement): void+Remove(element: IElement): void

public void Handle(ShareContext context){    Console.WriteLine(\"当前状态是： 状态1\");    context.SetState(context.GetState(\"2\"));}

Handler

Context  环境类

-exp: IAbstractExpression

+Context()+Operation(info: string): void

策略模式将每个算法封装到不同的策略类中，使得它们可以互换。是对算法的封装，把使用算法的职责和算法本身分离，委派给不同的对象负责。抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。环境（Context）类：持有一个策略类的引用，最终给客户端调用。

访问者模式访问者模式即表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。适用于数据结构相对稳定的系统， 它把数据结构和作用于数据结构之上的操作之间的耦合度降低，使得操作集合可以相对自由地改变。抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现。

ASP.NET的MVC模式之一，Front Controller模式，分为Handler和Command树两个部分，Handler处理公共逻辑，接收Http请求及相关的参数，并根据输入参数选择正确的命令对象，然后将控制权传递到Command对象，由其完成后面的操作。

ConcreteMediator  具体中介者

-colleagues: List<Colleague>

Handler  抽象处理者

+SetNext(next: Handler): void+GetNext(): Handler+HandlerRequest(request: string): bool

State 抽象状态类

迭代器模式提供一种方法来顺序访问一个集合对象中的元素，而无需暴露其内部的结构。.Net中 IEnumerator 接口扮演的就是迭代器角色，IEnumberable接口则扮演的就是抽象聚集的角色，只有一个GetEnumerator()方法。抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 HasNext()、First()、Next() 等方法。具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

Mediator 抽象中介者

+ConcreteColleague2()+Receive(message: string): void+Send(message: string): void

TerminalExpression终结符表达式类

Algorithm(){ strategy.Algorithm();}

Context 环境类

-state: State

+Context()+SetState(s: State): void+GetState(): State+Handle(): void

<<interface>>ICloneable

+ Clone(): Object

<<interface>>IAbstractExpression 抽象表达式类

职责链模式

PrototypeCaretaker 原型管理者

-opt: OriginatorPrototype

+SetMemeto(opt: OriginatorPrototype): void+GetMemento(): OriginatorPrototype

Subject  抽象目标

-observers: List<IObserver>

+Add(observer: IObserver): void+Remove(observer: IObserver): void+Notify(): void

//模板方法，定义了算法骨架public void TemplateMethod(){   SpecificMethod();   Method1();             Method2();} 

ConcreteAggregate 具体聚合

list: List<Object>

ConcreteObserver2

解释器模式