软件设计师23种设计模式总结汇编.docx
- 文档编号:23736281
- 上传时间:2023-05-20
- 格式:DOCX
- 页数:81
- 大小:2.72MB
软件设计师23种设计模式总结汇编.docx
《软件设计师23种设计模式总结汇编.docx》由会员分享,可在线阅读,更多相关《软件设计师23种设计模式总结汇编.docx(81页珍藏版)》请在冰豆网上搜索。
软件设计师23种设计模式总结汇编
创建型
结构型
行为型
类
FactoryMethod
Adapter
Interpreter
TemplateMethod
对象
AbstractFactory
Builder
Prototype
Singleton
Apapter(对象)
Bridge
Composite
Decorator
Façade
Flyweight
Proxy
ChainofResponsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor
1.AbstractFactory(抽象工厂)
提供一个创建一系列相关或互相依赖对象的接口,而无须制定它们具体的类。
AbstractFactory抽象工厂
classProgram
{
staticvoidMain(string[]args)
{
AbstractFactoryfactory1=newConcreteFactory1();
Clientc1=newClient(factory1);
c1.Run();
AbstractFactoryfactory2=newConcreteFactory2();
Clientc2=newClient(factory2);
c2.Run();
Console.Read();
}
}
abstractclassAbstractFactory
{
publicabstractAbstractProductACreateProductA();
publicabstractAbstractProductBCreateProductB();
}
classConcreteFactory1:
AbstractFactory
{
publicoverrideAbstractProductACreateProductA()
{
returnnewProductA1();
}
publicoverrideAbstractProductBCreateProductB()
{
returnnewProductB1();
}
}
classConcreteFactory2:
AbstractFactory
{
publicoverrideAbstractProductACreateProductA()
{
returnnewProductA2();
}
publicoverrideAbstractProductBCreateProductB()
{
returnnewProductB2();
}
}
abstractclassAbstractProductA
{
}
abstractclassAbstractProductB
{
publicabstractvoidInteract(AbstractProductAa);
}
classProductA1:
AbstractProductA
{
}
classProductB1:
AbstractProductB
{
publicoverridevoidInteract(AbstractProductAa)
{
Console.WriteLine(this.GetType().Name+
"interactswith"+a.GetType().Name);
}
}
classProductA2:
AbstractProductA
{
}
classProductB2:
AbstractProductB
{
publicoverridevoidInteract(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);
}
}
2.Builder(生成器)
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
Builder生成器
classProgram
{
staticvoidMain(string[]args)
{
Directordirector=newDirector();
Builderb1=newConcreteBuilder1();
Builderb2=newConcreteBuilder2();
director.Construct(b1);
Productp1=b1.GetResult();
p1.Show();
director.Construct(b2);
Productp2=b2.GetResult();
p2.Show();
Console.Read();
}
}
classDirector
{
publicvoidConstruct(Builderbuilder)
{
builder.BuildPartA();
builder.BuildPartB();
}
}
abstractclassBuilder
{
publicabstractvoidBuildPartA();
publicabstractvoidBuildPartB();
publicabstractProductGetResult();
}
classConcreteBuilder1:
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
publicvoidAdd(stringpart)
{
parts.Add(part);
}
publicvoidShow()
{
Console.WriteLine("\n产品创建----");
foreach(stringpartinparts)
{
Console.WriteLine(part);
}
}
}
3.FactoryMethod(工厂方法)
定义一个用于创建对象的接口,让子类决定实例化哪一个类。
FactoryMethod使一个实例化延迟到其子类。
FactoryMethod工厂方法
classProgram
{
staticvoidMain(string[]args)
{
//
//基本方式:
薛磊风代表大学生学习雷锋
LeiFengxueleifeng=newUndergraduate();
xueleifeng.BuyRice();
xueleifeng.Sweep();
xueleifeng.Wash();
LeiFengstudent1=newUndergraduate();
student1.BuyRice();
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
{
publicstaticLeiFengCreateLeiFeng(stringtype)
{
LeiFengresult=null;
switch(type)
{
case"学雷锋的大学生":
result=newUndergraduate();
break;
case"社区志愿者":
result=newVolunteer();
break;
}
returnresult;
}
}
//雷锋工厂
interfaceIFactory
{
LeiFengCreateLeiFeng();
}
//学雷锋的大学生工厂
classUndergraduateFactory:
IFactory
{
publicLeiFengCreateLeiFeng()
{
returnnewUndergraduate();
}
}
//社区志愿者工厂
classVolunteerFactory:
IFactory
{
publicLeiFengCreateLeiFeng()
{
returnnewVolunteer();
}
}
4.Prototype(原型)
用原型实例制定创建对象的种类,并且通过复制这些原型创建新的对象。
Prototype原型
classProgram
{
staticvoidMain(string[]args)
{
ConcretePrototype1p1=newConcretePrototype1("I");
ConcretePrototype1c1=(ConcretePrototype1)p1.Clone();
Console.WriteLine("Cloned:
{0}",c1.Id);
ConcretePrototype2p2=newConcretePrototype2("II");
ConcretePrototype2c2=(ConcretePrototype2)p2.Clone();
Console.WriteLine("Cloned:
{0}",c2.Id);
//Waitforuser
Console.Read();
}
}
abstractclassPrototype
{
privatestringid;
//Constructor
publicPrototype(stringid)
{
this.id=id;
}
//Property
publicstringId
{
get{returnid;}
}
publicabstractPrototypeClone();
}
classConcretePrototype1:
Prototype
{
//Constructor
publicConcretePrototype1(stringid)
:
base(id)
{
}
publicoverridePrototypeClone()
{
//Shallowcopy
return(Prototype)this.MemberwiseClone();
}
}
classConcretePrototype2:
Prototype
{
//Constructor
publicConcretePrototype2(stringid)
:
base(id)
{
}
publicoverridePrototypeClone()
{
//Shallowcopy
return(Prototype)this.MemberwiseClone();
}
}
5.Singleton(单例)
保证一个类仅有一个实例,并提供一个访问它的全局访问点。
Singleton
classProgram
{
staticvoidMain(string[]args)
{
Singletons1=Singleton.GetInstance();
Singletons2=Singleton.GetInstance();
if(s1==s2)
{
Console.WriteLine("Objectsarethesameinstance");
}
Console.Read();
}
}
classSingleton
{
privatestaticSingletoninstance;
privatestaticreadonlyobjectsyncRoot=newobject();
privateSingleton()
{
}
publicstaticSingletonGetInstance()
{
if(instance==null)
{
lock(syncRoot)
{
if(instance==null)
{
instance=newSingleton();
}
}
}
returninstance;
}
}
1.Adapter(适配器)
将一个类的接口转换成客户希望的另一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
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();
}
}
2.Bridge(桥接)
将抽象部分与其实现部分分离,使它们都可以独立的变化。
Bridge
classProgram
{
staticvoidMain(string[]args)
{
Abstractionab=newRefinedAbstraction();
ab.SetImplementor(newConcreteImplementorA());
ab.Operation();
ab.SetImplementor(newConcreteImplementorB());
ab.Operation();
Console.Read();
}
}
classAbstraction
{
protectedImplementorimplementor;
publicvoidSetImplementor(Implementorimplementor)
{
this.implementor=implementor;
}
publicvirtualvoidOperation()
{
implementor.Operation();
}
}
classRefinedAbstraction:
Abstraction
{
publicoverridevoidOperation()
{
implementor.Operation();
}
}
abstractclassImplementor
{
publicabstractvoidOperation();
}
classConcreteImplementorA:
Implementor
{
publicoverridevoidOperation()
{
Console.WriteLine("具体实现A的方法执行");
}
}
classConcreteImplementorB:
Implementor
{
publicoverridevoidOperation()
{
Console.WriteLine("具体实现B的方法执行");
}
}
3.Composite(组合)
将对象组合成树形结构以表示“部分----整体”的层次结构。
Composite使得用户对单个对象和组合对象的使用具有一致性。
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=newLeaf("LeafD");
root.Add(leaf);
root.Remove(leaf);
root.Display
(1);
Console.Read();
}
}
abstractclassComponent
{
protectedstringname;
publicComponent(stringname)
{
this.name=name;
}
publicabstractvoidAdd(Componentc);
publicabstractvoidRemove(Componentc);
publicabstractvoidDisplay(intdepth);
}
classComposite:
Component
{
privateList
publicComposit
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 软件 设计师 23 设计 模式 总结 汇编
![提示](https://static.bdocx.com/images/bang_tan.gif)