软件设计师23种设计模式总结

创建型结构型行为型

Interpreter

类FactoryMethodAdapter

TemplateMethod

ChciinofResponsibility

Apapter(对象)Command

BridgeIterator

AbstractFactory

CompositeMediator

Builder

对象DecoratorMemento

Prototype

Fa9adeObserver

Singleton

FlyweightState

ProxyStrategy

Visitor

AbstractFactory（抽象工厂）

提供一个创建一系列相关或互相依赖对象的接口，而无须制定它们具体的类。

AbstractFactory抽象工厂

classProgram

(

staticvoidMain(string[]args)

(

AbstractFactoryfactoryl=newConcreteFactoryl();

Clientcl=newClient(factoryl);

cl.Run();

AbstractFactoryfactory2=newConcreteFactory2();

Clientc2=newClient(factory2);

c2.Run();

Console.Read();

)

)

abstractclassAbstractFactory

(

publicabstractAbstractProductACreateProductA();

publicabstractAbstractProductBCreateProductB();

)

classConcreteFactoryl:AbstractFactory

(

publicoverrideAbstractProductACreateProductA()

(

returnnewProductAlf);

)

publicoverrideAbstractProductBCreateProductB()

returnnewProductBl();

)

)

classConcreteFactory2:AbstractFactory

(

publicoverrideAbstractProductACreateProductA()

(

returnnewProductA2();

)

publicoverrideAbstractProductBCreateProductB()

(

returnnewProductB2();

)

)

abstractclassAbstractProductA

(

)

abstractclassAbstractProductB

(

publicabstractvoidInteractfAostractProductAa);

)

classProductAl:AbstractProductA

(

)

classProductBl:AbstractProductB

(

publicoverridevoidlnteract(AbstractProductAa)

(

Console.WriteLine(this.GetType().Name+

"interactswith"+a.GetType().Name);

)

)

classProductA2:AbstractProductA

(

)

classProductB2:AbstractProductB

(

publicoverridevoidlnteract(AbstractProductAa)

Console.WriteLine(this.GetType().Name+

"interactswith"+a.GetType().Name);

)

)

classClient

privateAbstractProductAAbstractProductA;

privateAbstractProductBAbstractProductB;

〃Constructor

publicClient(AbstractFactoryfactory)

(

AbstractProductB=factory.CreateProductB();

AbstractProductA=factory.CreateProductA();

)

publicvoidRun()

(

AbstractProductB.Interact(AbstractProductA);

)

)

Builder(生成器)

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

/

Builder生成器

classProgram

(

staticvoidMain(string[]args)

(

Directordirector=newDirectorf);

Builderbl=newConcreteBuilderl();

Builderb2=newConcreteBuilder2();

director.Construct(bl);

Productpl=bl.GetResult();

pl.Show();

director.Construct(b2);

Productp2=b2.GetResult();

p2.Show();

Console.Read();

)

}

classDirector

publicvoidConstruct(Builderbuilder)

builder.BuildPartA();

builder.BuildPartB{);

)

)

abstractclassBuilder

(

publicabstractvoidBuildPartA();

publicabstractvoidBuildPartE();

publicabstractProductGetResult();

)

classConcreteBuilderl:Builder

(

privateProductproduct=newProduct();

publicoverridevoidBuildPartA()

(

product.Add("部件A");

)

publicoverridevoidBuildPartB()

(

product.Add("部件B");

}

publicoverrideProductGetResult()

(

returnproduct;

)

)

classConcreteBuilder2:Builder

(

privateProductproduct=newProduct();

publicoverridevoidBuildPartA()

(

product.Add("部件X");

}

publicoverridevoidBuildPartB()

(

product.Add("部件Y");

)

publicoverrideProductGetResult()

(

returnproduct;

)

)

classProduct

(

IList<string>parts=newList<string>();

publicvoidAdd(stringpart)

(

parts.Add(part);

)

publicvoidShow()

(

Console.WriteLine("\n产品创建--")；

foreach(stringpartinparts)

(

Console.WriteLine(part);

)

)

)

FactoryMethod(工厂方法)

定义,个用于创建对象的接口，让子类决定实例化哪•个类。FactoryMethod使•个实例化延迟到其子类。

/

FactoryMethod工厂方法

classProgram

(

staticvoidMain(string[]args)

(

//

〃基本方式:薛磊风代表大学生学习雷锋

LeiFengxueleifeng=newUndergraduate();

xueleifeng.BuyRicef);

xueleifeng.Sweep();

xueleifeng.Wash();

LeiFengstudentl=newUndergraduate();

studentl.BuyRicef);

LeiFengstudent2=newUndergraduate();

student2,Sweep();

LeiFengstudent3=newUndergraduate();

student3.Wash();

〃简单工厂模式

LeiFengstudentA=SimpleFactory.CreateLeiFeng("学雷锋的大学生");

studentA.BuyRice{);

LeiFengstudentB=SimpleFactory.CreateLeiFeng("学雷锋的大学生");

studentB.Sweep();

LeiFengstudentC=SimpleFactory.CreateLeiFeng("学雷锋的大学生");

studentC.Wash{);

〃工厂方法模式

IFactoryfactory=newUndergraduateFactory()；

LeiFengstudent=factory.CreateLeiFeng();

student.BuyRice{);

student.Sweep();

student.Wash();

Console.Read();

)

)

〃雷锋

classLeiFeng

(

publicvoidSweep()

(

Console.WriteLine("扫地")；

)

publicvoidWash()

(

Console.WriteLine(“洗衣”)；

)

publicvoidBuyRice()

(

Console.WriteLine("买米")；

)

)

〃学雷锋的大学生

classUndergraduate:LeiFeng

()

〃社区志愿者

classVolunteer:LeiFeng

()

〃简单雷锋工厂

classSimpleFactory

(

publicstaticLeiFengCrea:eLeiFeng(stringtype)

(

LeiFengresult=null;

switch(type)

{

case”学雷锋的大学生”：

result=newUndergraduate();

break;

case”社区志愿者”：

result=newVolunteer();

break;

)

returnresult;

)

)

〃雷锋工厂

interfaceIFactory

(

LeiFengCreateLeiFengO;

)

〃学雷锋的大学生工厂

classUndergraduateFactory:IFactory

(

publicLeiFengCreateLeiFeng()

(

returnnewUndergraduate();

}

)

〃社区志愿者工厂

classVolunteerFactory:IFactory

(

publicLeiFengCreateLeiFeng()

(

returnnewVolunteer();

)

)

Prototype(原型)

用原型实例制定创建对象的种类，并且通过复制这些原型创建新的对象。

/

Prototype原型

classProgram

staticvoidMain(string[]args)

(

ConcretePrototypelpl=newConcretePrototypel("l");

ConcretePrototypelcl=(ConcretePrototypel)pl.Clone();

Console.WriteLine("Cloned:{0}",cl.Id);

ConcretePrototype2p2=newConcretePrototype2("ll");

ConcretePrototype2c2=(ConcretePrototype2)p2.Clone();

Console.WriteLine("Cloned:{0}"zc2.ld);

//Waitforuser

Console.Read();

)

)

abstractclassPrototype

(

privatestringid;

//Constructor

publicPrototype(stringid)

(

this.id=id;

)

//Property

publicstringId

(

get{returnid;}

}

publicabstractPrototypeClone();

)

classConcretePrototypel:Prototype

(

//Constructor

publicConcretePrototypel(stringid)

:base(id)

(

)

publicoverridePrototypeClone()

//Shallowcopy

return(Prototype)this.MemberwiseClone();

)

)

classConcretePrototype2:Prototype

(

//Constructor

publicConcretePrototype2(stringid)

:base(id)

(

)

publicoverridePrototypeClone()

(

//Shallowcopy

return(Prototype)this.MemberwiseClone();

)

)

Singleton(单例)

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

/

Singleton

classProgram

(

staticvoidMain(string[]args)

(

Singletonsi=Singleton.Getlnstancef);

Singletons2=Singleton.Getlnstance();

if(sl==s2)

{

Console.WriteLinef'Objectsarethesameinstance")；

)

Console.Read();

)

)

classSingleton

(

privatestaticSingletoninstance;

privatestaticreadonlyobjectsyncRoot=newobject();

privateSingleton()

(

)

publicstaticSingletonGetlnstance()

if(instance==null)

lock(syncRoot)

if(instance==null)

(

instance=newSingleton();

)

)

)

returninstance;

)

)

1.Adapter（适配器）

将一个类的接口转换成客户希望的另一个接口。Adapter■模式使得原本由于接口不兼容而不能一起工作的那

些类可以一起工作。

图10-30类适配器结构图

Adapter

classProgram

(

staticvoidMain(string[]args)

(

Targettarget=newAdapter();

target.Request();

Console.Read();

)

)

classTarget

publicvirtualvoidRequest。

(

Console.WriteLine("普通请求")；

)

)

classAdaptee

(

publicvoidSpecificRequest()

(

Console.WriteLine("特殊请求)

)

)

classAdapter:Target

(

privateAdapteeadaptee=newAdaptee();

publicoverridevoidRequest()

(

adaptee.SpecificRequest();

)

)

Bridge(桥接)

将抽象部分与其实现部分分离，使它们都可以独立的变化。

/

Bridge

classProgram

(

staticvoidMain(string[]args)

(

Abstractionab=newRefinedAbstraction();

ab.Setlmplementor(newConcretelmplementorA());

ab.Operationf);

ab.SetlmplementorfnewConcretelmplementorB());

ab.Operationf);

Console.Read();

)

)

classAbstraction

protectedImplementorimplementor;

publicvoidSetlmplementor(lmplementorimplementor)

(

this.implementor=implementor;

)

publicvirtualvoidOperationf)

(

implementor.Operaton();

)

)

classRefinedAbstraction:Abstraction

(

publicoverridevoidOperation()

(

implementor.Operaton();

)

)

abstractclassImplementor

(

publicabstractvoidOperation();

)

classConcretelmplementorA:Implementor

(

publicoverridevoidOperation()

(

Console.WriteLine("具体实现A的方法执行");

)

)

classConcretelmplementorB:Implementor

(

publicoverridevoidOperation()

(

Console.WriteLine("具体实现B的方法执行)

)

)

2.Composite(组合)

将对象组合成树形结构以表示“部分--整体”的层次结构。Composite使得用户对单个对象和组合对象的使

用具有一致性。

图10・33组合模式结构图

Composite

classProgram

(

staticvoidMain(string(]args)

(

Compositeroot=newComposite("root")；

root.Add(newLeaf("LeafA"));

root.Add(newLeaf("LeafB"))；

Compositecomp=newComposite("CompositeX");

comp.Add(newLeaf("LeafXA"));

comp.Add(newLeaf("LeafXB"))；

root.Add(comp);

Compositecomp2=newComposite("CompositeXY"];

comp2.Add(newLeaf("LeafXYA"));

comp2.Add(newLeaf("LeafXYB"))；

comp.Add(comp2);

root.Add(newLeaf("LeafC"))；

Leafleaf=newLeaff'LeafD");

root.Add(leaf);

root.Remove(leaf);

root.Display(l);

Console.Read();

)

abstractclassComponent

(

protectedstringname;

publicComponent(stringname)

(

=name;

)

publicabstractvoidAdd(Componentc);

publicabstractvoidRemove(Componentc);

publicabstractvoidDisplay(intdepth);

)

classComposite:Component

(

privateList<Component>children=newList<Component>();

publicComposite(stringname)

:base(name)

()

publicoverridevoidAdd(Componentc)

(

children.Add(c);

)

publicoverridevoidRemove(Componentc)

(

children.Remove(c);

}

publicoverridevoidDisphy(intdepth)

(

Console.WriteLine(newString"',depth)+name);

foreach(Componentcomponentinchildren)

{

component.Display(depth+2);

)

)

)

classLeaf:Component

(

publicLeaf(stringname)

:base(name)

()

publicoverridevoidAdd(Componentc)

Console.WriteLinef'Cannotaddtoaleaf")；

)

publicoverridevoidRemove(Componentc)

(

Console.WriteLine("Cannotremovefromaleaf")；

)

publicoverridevoidDisplay(intdepth)

(

Console.WriteLine(newString('-',depth)+name);

)

)

Decorator(装饰)

动态地给一个对象添加一些额外的职贡。就增加功能而言,Decorator模式比生成子类更加J灵活。

/

Decorator

classProgram

(

staticvoidMain(string[]args)

(

ConcreteComponentc=newConcreteComponent();

ConcreteDecoratorAdl=newConcreteDecoratorAf);

ConcreteDecoratorBd2=newConcreteDecoratorB();

dl.SetComponent(c);

d2.SetComponent(dl);

d2.Operation();

Console.Read();

)

)

abstractclassComponent

(

publicabstractvoidOperation();

)

classConcreteComponent:Component

(

publicoverridevoidOperation()

Console.WriteLine("具体对象的操作");

)

)

abstractclassDecorator:Component

(

protectedComponentcomponent;

publicvoidSetComponent(Componentcomponent)

(

ponent=component;

)

publicoverridevoidOperation()

(

if(component!=null)

{

component.Operation();

)

)

)

classConcreteDecoratorA:Decorator

(

privatestringaddedState;

publicoverridevoidOperation()

(

base.Operationf);

addedState="NewState";

Console.WriteLine("具体装饰对象A的操作");

)

)

classConcreteDecoratorB:Decorator

(

publicoverridevoidOperation()

(

base.Operation{);

AddedBehavior();

Console.WriteLine("具体装饰对象B的操作”);

)

privatevoidAddedBehavior()

)

)

Facade(夕卜观)

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易

使用。

/

Facade

classProgram

(

staticvoidMain(string(]args)

(

Facadefacade=newFacade();

facade.MethodA();

facade.MethodB();

Console.Read();

)

)

classSubSystemOne

(

publicvoidMethodOne()

(

Console.WriteLine("子系统方法一”)；

)

)

classSubSystemTwo

(

publicvoidMethodTwo()

(

Console.WriteLine("子系统方法二”);

)

)

classSubSystemThree

(

publicvoidMethodThree,)

(

Console.WriteLinef,子系统方法三")；

)

)

classSubSystemFour

(

publicvoidMethodFour()

Console.WriteLine("子系统方法四”);

)

)

classFacade

(

SubSystemOneone;

SubSystemTwotwo;

SubSystemThreethree;

SubSystemFourfour;

publicFacade()

one=newSubSystemOnef);

two=newSubSystemTwo();

three=newSubSystemThree();

four=newSubSystemFour{);

)

publicvoidMethodA()

(

Console.WriteLine("\n方法组A()--");

one.MethodOne();

two.MethodTwo();

four.MethodFour();

publicvoidMethodB()

Console.WriteLine("\n方法组B()-一");

two.MethodTwo();

three.MethodThreeQ;

）

3.Flyweight（享元）

运用共享技术有效地支持大量细粒度的对象。

图10-36享元模式结构图

Flyweight

classProgram

(

staticvoidMain(string(]args)

(

intextrinsicstate=22;

FlyweightFactoryf=newFlyweightFactoryO;

Flyweightfx=f.GetFlyweight("X");

fx.Operation(-extrinsicstate);

Flyweightfy=f.GetFlyweightf'Y");

fy.Operation(-extrinsicstate);

Flyweightfz=f.GetFlyweightC'Z");

fz.Operation(--extrinsicstate);

UnsharedConcreteFlyweightuf=newUnsharedConcreteFlyweight();

uf.Operation(-extrinsicstate);

Console.Read();

}

classFlyweightFactory

privateHashtableflyweights=newHashtable();

publicFlyweightFactory()

(

flyweights.AddC'X",newConcreteFlyweightf));

flyweights.Add("Y",newConcreteFlyweightf));

flyweights.Add("Z",newConcreteFlyweight());

)

publicFlyweightGetFlyweight(stringkey)

(

return((Flyweight)flyweights(key])；

)

)

abstractclassFlyweight

(

publicabstractvoidOperation(intextrinsicstate);

)

classConcreteFlyweight:Flyweight

(

publicoverridevoidOperation(intextrinsicstate)

(

Console.WriteLine("具体Flyweight:"+extrinsicstate);

)

)

classUnsharedConcreteFlyweight:Flyweight

(

publicoverridevoidOperation(intextrinsicstate)

(

Console.WriteLine("不共享的具体Flyweight:"+extrinsicstate);

)

)

4.Proxy(代理)

为其他对象提供一种代理以控制对这个对象的访问。

ClientSubject

图10・37代理模式结构图

Proxy

classProgram

(

staticvoidMain(string[]args)

(

Proxyproxy=newProxy();

proxy.Request();

Console.Read();

)

)

abstractclassSubject

(

publicabstractvoidRequest();

)

classRealSubject:Subject

(

publicoverridevoidRequest()

(

Console.WriteLine("真实的请求)

)

)

classProxy:Subject

(

RealSubjectrealSubject;

publicoverridevoidRequestf)

(

if(realSubject==null)

realSubject=newRealSubject();

)

realSubject.RequestQ;

)

)

ChainofResponsibility(责任链)

使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连城一条链，并沿着

这条链传递该请求，直到有一个对象处理它为止。

/

ChainofResponsibility

classProgram

(

staticvoidMain(string[]args)

(

Handlerhl=newCcncreteHandlerlf);

Handlerh2=newCcncreteHandler2();

Handlerh3=newCcncreteHandler3();

hl.SetSuccessor(h2);

h2.SetSuccessor(h3);

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

foreach(intrequestmrequests)

(

hl.HandleRequest(request);

)

Console.Read();

}

)

abstractclassHandler

(

protectedHandlersuccessor;

publicvoidSetSuccessor(Handlersuccessor)

(

this.successor=successor;

)

publicabstractvoidHandleRequestfintrequest);

)

classConcreteHandlerl:Handler

publicoverridevoidHandleRequest(intrequest)

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

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

this.GetType().Name,request);

)

elseif(successor!=null)

{

successor.HandleRequest(request);

)

)

)

classConcreteHandler2:Handler

(

publicoverridevoidHandleRequest(intrequest)

(

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

(

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

this.GetTypeQ.Name,request);

)

elseif(successor!=null)

{

successor.HandleRequest(request);

)

)

)

classConcreteHandler3:Handler

(

publicoverridevoidHandleRequest(intrequest)

(

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

(

处理请求

Console.WriteLine("{0}{1}",

this.GetType().Name,request);

)

elseif(successor!=null)

{

successor.HandleRequest(request);

)

)

)

Command(命令)

将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对于请求排队或记录请求日志，以及

支持可撤销的操作。

Command

classProgram

(

staticvoidMain(string[]args)

(

Receiverr=newReceiver();

Commandc=newConcreteCommand(r);

Invokeri=newlnvoker();

//Setandexecutecommand

i.SetCommand(c);

i.ExecuteCommand();

Console.Read();

)

)

abstractclassCommand

(

protectedReceiverreceiver;

publicCommand(Receiverreceiver)

(

this.receiver=receiver;

)

abstractpublicvoidExeccte();

)

classConcreteCommand:Command

(

publicConcreteCommand(Receiverreceiver)

base(receiver){}

publicoverridevoidExecute()

(

receiver.Action();

)

)

classReceiver

(

publicvoidAction()

Console.WriteLine("执行请求!");

)

)

classInvoker

(

privateCommandcommand;

publicvoidSetCommand(Commandcommand)

(

mand=command;

)

publicvoidExecuteCommand()

(

command.Executed;

)

)

Interpreter(解释器)

给定一个语言，定义它的文法的一种表示，并定义个解释器，这个解释器使用该表示来解释语言中的句子。

/

Interpreter

classProgram

(

staticvoidMain(string(]args)

(

Contextcontext=newContextf);

IList<AbstractExpression^>list=newList<AbstractExpression>();

list.Add(newTerminalExpression());

list.Add(newNonterminalExpression());

list.Add(newTerminalExpression());

list.Add(newTerminalExpression());

foreach(AbstractExpressionexpinlist)

{

exp.lnterpret(context);

)

Console.Read();

)

)

classContext

(

privatestringinput;

publicstringInput

get{returninput;}

set{input=value;}

)

privatestringoutput;

publicstringOutput

(

get{returnoutput;)

set{output=value;}

)

)

abstractclassAbstractExpression

(

publicabstractvoidlnterpret(Contextcontext);

)

classTerminalExpression:AbstractExpression

(

publicoverridevoidlnterpret(Contextcontext)

(

Console.WriteLine("终端解释器”)；

)

)

classNonterminalExpression:AbstractExpression

(

publicoverridevoidlnterpret(Contextcontext)

(

Console.WriteLine("非终端解称器")；

)

)

Iterator"(迭代器)

提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。

/

Iterator

classProgram

(

staticvoidMain(string[]args)

(

ConcreteAggregatea=newConcreteAggregatef);

a[0]=“大鸟”；

a[l]="小菜”；

a[2]="行李”；

a[3]="老外”;

a[4]=”公交内部员工”;

a⑸="小偷”；

Iteratori=newConcretelterator(a);

//Iteratori=newConcretelteratorDesc(a);

objectitem=i.Firstf);

while(!i.lsDone())

{

Console.WriteLine("{0}请买车票!，i.Currentltem。);

i.Next();

)

Console.Read();

)

)

abstractclassAggregate

(

publicabstractIteratorCreatelteratorf);

)

classConcreteAggregate:Aggregate

(

privateIList<object>items=newList<object>();

publicoverrideIteratorCreatelteratorf)

(

returnnewConcretelterator(this);

)

publicintCount

(

get{returnitems.Count;}

)

publicobjectthis[intindex]

(

get{returnitemsfindex];}

set{items.lnsert(index,value);}

)

)

abstractclassIterator

(