行为型设计模式

一、职责链

职责链模式： 使用多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

职责链模式结构图

abstarct class Handler{

protect Handler successor;

public void SetSuccessor(Handler successor){

this.successor=successor;

}

public abstract void HandlerRequest(int request);

}

class ConcreteHandler1:public Handler{

public void HandlerRequest(int request){

if(request>=0&&request<10){

Console.WriteLine("{0}处理请求{1}",

this.GetType().Name,request); ---->转移到下一位

}

}

}

class ConcreteHadler2:public Hadler{

public void HandlerRequest(int request){

if(reqeust>=10&&request<20){

Console.WriteLine("{0}处理请求{1}",

this.GetType().Name,request);

}else if(successor!=null){

successor.HandlerRequest(request);

}

}

}

class ConcreteHadler3:public Hadler{

public void HandlerRequest(int request){

if(reqeust>=20&&request<30){

Console.WriteLine("{0}处理请求{1}",

this.GetType().Name,request);

}else if(successor!=null){

successor.HandlerRequest(request);

}

}

}

static void Main(Stirng []args){

Handler h1=new ConcreteHandler1();

Handler h2=new ConcreteHandler2();

Handler h3=new ConcreteHandler3();

h1.SetSuccessor(h2);

h2.SetSuccessor(h3);

int []={2,5,14,22,18,3,27,20};

foreach(int request in request){

h1.HandlerRequest(request);

}

Consloe.Read();

}

职责链的好处：

这其中最关键的是当客户提交一个请求时，请求是沿链传递至有一个ConcreteHandler对象负责处理它。

这使得接受者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互链接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选者的引用。大大降低了耦合度。

二、策略模式

目的：抽象和实现相分离

不同属性的实现分开，需要哪个属性类屈从哪个属性类中去调用相应需要的，

它们定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的用户。

策略模式结构图

class Aricraft{

protected:

FlyBehavior * flyp;

TakeOffBehavior * takeoffp;

public:

virtual void Fly()=0;

virtual void TakeOff()=0;

};

class Ariplane:public Aricracft{

public:

Ariplane(FlyBehavior * f,TakeOff *t){

flyp=f;

takeoffp=t;

}

void FLy(){

flyp->fly();

}

void TakeOff{

takeoffp->takeoff()

}

};

//client

Subsoricfly *ps=new Subsoricfly();

longdistancefy *pl=new longdistacefly();

Ariplane *pa=new Aricracft(ps,pl);

pa->Fly();

pa->Takeoff()

三、模板模式

模板模式定义一个操作算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。通俗点说，完成一件事情，有固定的数个步骤，但是每个步骤根据对象的不同，而实现细节不同；就可以在父类中定义一个完成该事情的总方法，按照完成事件所需要的步骤去调用其每个步骤的实现方法。每个步骤的具体实现，由子类完成。

抽象父类：实现模板方法，定义了算法的骨架

具体类;实现抽象类中的抽象方法，即不同的对象具体具体实现细节

class AbstractClass{

public:

void Templantmethod(){

this->primitire1();

this->primitire2();

}

protected:

virtual void primitire1()=0;

virtual void primitire1()=0;

};

class concretireA:public AstractClass{

protected:

void primitire1(){

}

void primitire2(){

}

};

class concretireB:public AbstractClass{

protected:

void primitire1(){

}

void primitire2(){

}

};

//client

AbstractClass *Pa=new concretireA();

Pa-> Templantmethod();

模板模式的优点：

1）具体细节步骤实现定义在子类中，子类定义详细处理算法是不会改变算法整体结构的。

2）代码复用的技术，在数据库设计中尤为重要

3）存在一种反向的控制结构，通过一个父类调用其子类的操作，通过子类对父类进行扩展增加新的行为，符合“开闭原则”。

不足：

每个不同的实现都需要定义一个子类，会导致类的个数增加，系统更加庞大。

四、访问者模式

表示一个作用于某对象结构中的各个元素的操作。它使你可以在不改变个元素的类的前提下定义作用与这些元素的新操作。

访问者模式结构图

ConcreteElement每个类声明一个Visit操作

abstract class Visitor{

public abstract void VisitConcreteElementA(ConcreteElementA concreteElement);

public abstract void VisitConsreteElemnetB(ConcreteElementB concreteElement);

}

class ConcreteVisitor1:Visitor{

public override void VisitConcreteElementA(ConcreteElementA concreteElementA){

Console.WriteLine("{0}被{1}访问",concreteElementA.GetType().Name,this.GetType().Name);

}

public override void VisitConcreteElementB(ConcreteElementB concreteElementB){

Console.WriteLine("{0}被{1}访问",concreteElementB.GetType().Name,this.GetType().Name);

}

}

class ConcreteVisitor2:Visitor{

//代码与上述类类似

}

abstract calss Element{

public abstract void Accept(Visitor visitor);

}

class ConcreteElementA:Element{

public override void Accept(Visitor visitor){

visitor.VisitorCOncreteElementA(this);

}

public void Operaion(){ }

}

class ConcreteElementB:Element{

public override void Accept(Visitor visitor){

visitor.VisitorCOncreteElementB(this);

}

public void Operaion(){ }

}

class ObjectStructure{

private IList<Element> elements=new List<Element>();

public void Attach(Element element){

elements.Add(element);

}

public void Detach(Element element){

elements.Remove(element);

}

public void Accept(Visitor visitor){

foreachElement e in elements(){

e.Accept(visitor);

}

}

}

static void Main(){

ObjectStructure -new ObjectStructure();

o.Attach(new ConcreteElementA);

o.Attach(new ConcreteElementB);

ConcreteVisitor1 v1=new ConcreteVisitor1();

ConcreteVisitor2 v2=new ConcreteVisitor2();

o,Accept(v1);

o.Accept(v2);

Consloe.Read();

}

访问者模式适用于数据结构相对稳定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。

访问者模式是要把处理数据从结构分离出来‘。其实它的最大优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中调一个访问者对象中。

缺点：使得、增加新的数据结构变得困难了。