23种设计模式(含例题)

1、创建型模式:这里指出了关联的product !所以说，一个Factory 和一个Product 是一一对应的关系。Factory method:定义一个用于创建对象的接口，让子类决定实例化哪一个类 。Factory Method使一个类的实例化延迟到其子类接口函数：Creator:FactoryMethod:纯虚函数，由派生类实现，创建出对应的Product.由相应的Factory派生类来生成Product的派生类，一个Factory和一个Product是一一对应的关系。也就是说如果 要新增一种Product那么也要对应的新增一个 Factory 。每个factory负责自身产品创建的策略，保

2、证各自；,的灵活性，符合单一职责原则。Abstract factory:Abstract Factory模式是为创建一组（多类）相关或依赖的对象提供创建接口，而 Factory method 是为一类对象提供创建接口或延迟对象的创建到子类中实现。Abstract Factory模式通常都是使用Factory method 实现Builder模式是基于这样的一个情况：一个对象可能有不同的组成部分 ，这几个部分的创建具有多样性，但是各个部分 之间装配的方式是一致的.Director:Construct函数中固定了各个组成部分的装配方式，而装配用到的具体组成部分由Builder的派生类实现.多态的零

3、件制造、一致的装配过程(多态的)各零件组成了 product装配方式：完成各组件间的关联、组装 I -*接口：Builder:BuildPart()是对l个对象不同部分的构建函数接口,Builder的派生类来具体实现Director:Construct()通过调用上面的接口函数完成各个部分的装配实现：Builder模式基于以下几个面向对象的设计原则：1)把变化的部分提取出来形成一个基类和对应的接口函数2)采用聚合的方式聚合了会发生变化的基类，就是这里Director聚合了 Builder类的指针.适用于以下情况：1)当创建复杂对象的算法应该独立于该对象的组成部分的装配方式时2)当构造过程必须允

4、许被构造的对象有不同的表示时Prototype:Prototype 模式其实就是常说的"虚拟构造函数"，通过不同派生类的 Clone()完成"虚拟构造函数"的效果Cli"iOperaloflO 9DfDtOtVP?A PrtnaiypeCtonef浅克隆” &深克隆Ip - pOtot/pe MJkJRE fC on cm怩 From W口。1CkJiet； pcorKteieynjtotype2Ctoflftl) 9Jreturn 8科SC#rorumcflpyjewlf接 口函数：Prototype:Clone():纯虚函数，根据不

5、同的派生类来实例化创建对象Singleton:保证一个类仅有一个实例，并提供一个访问它的全局访问点X（WfTi un咫uMn备门心Srnglstain state lnsTanc«() AS扑9他何卜。*亡GetShgietonDaiaf)jtite unique In 叫日 ng snirinnUeiaSingleton模式其实是对全局静态变量的一个替代策略，在C+中是这样实现的：1）提供一个类的静态成员变量，类的静态成员变量对于一个类的所有对象是惟一的2）提供访问这个静态成员变量的静态成员函数，对类的所有对象而言也是惟一的.结构性模式:Adapt模式使得原本由于接口不兼容而不能一

6、起工作的那些类可Adapter ：将一个类的接口转换成客户希望的另外一个接口 O以一起工作。接口转换）C油ntJargelAdaptsAdaplar把完成同样的功能但是接口不能兼容的类,桥接在一起；这个模式使得复用旧的接口成为可能Target类和用户接口，通过Adapter桥接后，幕后变为Adaptee类实现BridgeImplementor:OperationImpl():定义了为实现Abstraction 需要的基本操作，由派生类具体实现。在Bridge模式中，系统被分为两个相对独立的部分，Abstraction 是抽象部分，Implementor是实现部分，这两个部分可以互相独立地进行修

7、改。当需要从Abstraction派生一个子类时，不再通过继承方式实现，而是只需在Implementor中添加一个子类而已(；右边的这颗类树开始变得扁平.)，Abstraction无需任何变化。风格变得elegant !尽量使用组合/聚合关系而不是继承关系 ："favor composition over Inheritance"Bridge的实现方式和Builder十分相近，本质上是一样的，只是封装的内容不一样.共同点：抽象出来一个基类，这个基类里面定义了共性行为，形成接口函数 聚合一个基类的指针，把这个指针的使用封装在一个函数中Builder封装了不同的生成组成部分的方

8、式，而Bridge封装了不同的实现方式.Composite ：Composite使得用户对单个对象和组合对象的使用具有一致性。(；图元的组合处理、文件和文件夹的复制)component 为基类，leaf为单个对象，composite 为组合对象，内含一个component 数据结构(比如：array、tree);Composite模式是为解决组件之间的递归组合提供了很好的解决办法接口函数：Operatation():共有的行为，由各个子类具体实现.含有子组件的类：Add(), Remove(), GetChild()应用情况：想要表示对象的整个或部分的层次结构需要客户端忽略复合对象和单个对象之

9、间的差异结构可以具有任何级别的复杂性而且是动态的Decorator ：动态地给一个对象添加一些额外的“装饰”。Decorator模式比生成子类更为灵活，它不是通过继承实现的，而是通过组合。通过继承的方式会带来系统的复杂 性，因为继承的深度会变得很深。动态的添加装饰，提供了比继承更有弹性的替代方案接口函数：Operation （）: Decorator 类对component 类的"装饰"，是通过operation。的多态调用实现的Decorator 的派生类装饰 ConcreateComponent类的对象.实现要点是：Decorator 和ConcreateCompone

10、nt者B继承自 Component,;Decorator 维护了一个指向Component的指针，从而可以实现对 Operation。 的动态调用.优点：1、使得整个类树变得更扁平化；2、动态,透明”的方式来添加职责，使得父子类间的关系更简约化应用情况：想要在单个对象中动态、透明的添加装饰，这样不会影响其他对象；想要在以后可能要修改的对象中添加职责无法通过静态子类化实现扩展时Fa? ade :Facade外观模式为子系统中的各类（或结构与方法）提供一个简明一致的界面，隐藏子系统的复杂性，使子 系统更加容易使用。为子系统中的一组接口所提供的一个一致的界面（在日常开发中，早已大量应用）Facade

11、类将客户端与子系统的内部复杂性分隔开，使得客户端只需要与Facade对象打交道，而不需要与子系统内部的很多对象打交道。 适用情况：为一个复杂子系统提供一个简单接口。提高子系统的独立性。在层次化结构中，可以使用 Facade模式定义系统中每一层的入口。FlyWeightFlyweight（享元模式）在大量使用可被共享的对象的时候经常使用。当需要一个对象的时候，先去查询是否已经存在了，如果没有就生成，有的话就直接使用.注意共性、个性的协调处理FlyweightFactory是个对象构造工厂，拥有一个对象池（list实现）。当Client需要一个对象时候就会向FlyweightFactory发出tt

12、求GetFlyweight（） , GetFlyweight（）会遍历对象池中的对象，如果已经存在则直接返回否则创建一个新的对象返回。含有缓冲池，记录内容状态内部对象，可共享（外部对象，不可共享通过共享一个接口来避免使用多个具有相同信息的实例所带来的开销。避免大量相同对象造成的开销，通常是内存消耗各对象将共性进行共享，同时又保留自己的个性Proxy ：为对象提供一种代理以控制对这个对象的访问。至少在以下几种情况下可以用Proxy模式：Remote Proxy :为网络上的对象创建一个局部的本地代理，比如要操作一个网络上的一个对象（网络性能不 好的时候，问题尤其突出），我们将这个操纵的过程交给一

13、个代理去完成；Virtual Proxy :创建开销大的对象时候，比如显示一幅大的图片，我们将这个创建的过程交给代理去完成；Protection Proxy :对对象进行控制访问的时候，比如论坛中不同权限的用户将获得不同层次的操作权限，我们将这个工作交给一个代理去完成在特定情景下，满足某不条件时，再调用 RealSubject事前处理： 权限、条件、拦截nea-Reqi 阻蛇口;Subject.Request():定义了 Proxy和RealSubject 的公有接口，这样就可以在任彳需要使用到RealSubject 的地方都使用Proxy代理实现.Proxy其实是基于这样一种时常使用到的技术

14、 -某个对象直到它真正被使用到的时候才被初始化，在没有使用到的时候就暂时用 Proxy作一个占位符.这个模式实现的 要点就是Proxy和RealSubject 都继承自subject ,确保了他 们有共同的接口。优点：远程代理可以隐藏对象位于不同的地址空间的事实虚拟代理可以执行优化操作，例如根据需要创建一个对象注意：Fa?ade模式注重简化接口，Adapter模式注重转换接口，Bridge模式注重分离接口 (抽象)与其实现，Decorator 模式注重稳定接口的前提下为对象扩展功能。行为性模式Chain of ResponsibilityChain of Responsibility模式描述了

15、这样一类问题：将可能处理一个请求的对象联接成一个链，并将请求在这个链上传递，直到有对象处理该请求。接口：Handler.HandleRequset()处理请求，同时有一个指针 successor,指向后继对象。ConcreteHandler将自己的后继对象记录在自己的后继指针中，当一个请求到来时，ConcreteHandler 会先检查看自己有没有匹配的处理程序，如果有就自己处理，否则传递给它的后继。举例:消息的发送者并不MFC提供了消息的链式处理策略，处理消息的请求将沿着预先定义好的路径依次进行处理。 知道该消息最后是由那个具体对象处理的，但是结果是该消息被某个对象处理了。优点:降低了请求的

16、发送者和接收者之间的耦合关系 增加了为对象指定责任的灵活性适用情况:多个对象可以处理一个请求，而其处理器确实未知的在不确切指定处理对象的情况下，向其中的一个发送请求动态指定能够处理请求的对象集（链可能是个链表，也可能是个 tree 、 graph ）把响应函数放在这里，Command 激活后，会自动调用CommandCommand模式通过将命令封装到 Command 对象中，将接“者封装到 Receiver中。（callback 函数）CiiwlAar<n)marKlCone reieC orwnaftdWk配W o-将请求的处理者放到Command的具体子类活 Command 对象),

17、ConcreteCommandConcreteCommand 中。当请求到来时（Invoker发出Invoke 消息激 将处理请求交给Receiver对象进行处理。优点:将命令的发出者和执行者相分离（类似于callback 机制）适用情景:更容易添加新命令，因为不用修改已有的类想要通过要执行的动作来参数化对象要在不同的时间指定、排序及执行请求必须支持undo 、日志记录及事务、排队Interpreter :一些应用提供了内建的脚本或者宏语言来让用户可以定义他们能够在系统中进行的操作。目的就是为用户提供一个定义语言的语法解释器，然后通过这个解释器来解释语言中的句子。主要用在编译器中，在应用系统中

18、很少用到Interpreter 模式的Cent心工IInterpreter提供了两种表达式的解释方式：NonterminalExpression :负责中间过程的迭代解释;迭代处理TerminalExpression :最终解释Context类用于为解释过程提供一些附加的信息优点：容易修改并扩展语法Iterator ：为遍历一个集合中的各个元素提供了一致的方法，而又不需暴露该集合的内部表示但un （出w C口由白口归1配侬肝瑜，ConcreteAggregate中封装了对象集合，及算法的具体实现；Iterator只提供了算法的接口 .算法Iterator和容器Aggregate之间有一个明确的

19、约定。尽管容器内部的实现细节会各有不同（可能是array、list、或tree）,但在外部看来，提供的遍历算法却是一样的。举例：STL中的迭代器优点：支持各种集合的不同遍历简化了集合的接口适用情景：在不开放集合对象内部表示的情况下，访问集合对象 为遍历集合中的不同结构，提供了统一的接口Mediator每个 Colleague 维护一个 Mediator,Colleague1 和 Colleague2 之间的交互通过 ConcreteMediator提供的方法完成,Colleaguel 和Colleague2不必维护各自的引用，甚至不知道对方的存在优点：通过Mediator ,各个Colleag

20、ue就不必维护各自通信的对象和通信协议，降低了系统的耦合性；控制集中，便于管理Memento ：备忘录，捕获一个对象的“快照”，这样可以在不曝光其内容的情况下，返回到它的最初状态Originator是原件，memento是备份、是"快照"。memento 存储Originator 的"快照"，在不公开其内部细节的情况下，实现备份和恢复Observer :当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新.Doc & viewsutjj£ct->Gelbrate(J表示层和数据层之间的分离Observer 模式定义

21、的是一对多的关系，一个Subject 对应多个Obesrver 。当Subject 的状态发生变化时，通知与之对应的所有 Obesrver也去相应更新，同时支持动态的注册或注销Observer对象。要点：Subject内一般采用链表指针来关联Observer接口：Subject.Attach():对 Observer 的注册；Subject.Detach():对 Observer 的注销；Subject. Notify():通知所有关联 Observer 更新举例： 在MFC中，Doc/View 实现了 MVC的框架结构。当document 改变时，对应多种风格的 view 都相应 变更。Ob

22、server模式是应用最多、影响最广的模式之一.适用情景：对一个对象的修改涉及对其他对象的修改，且不知有多少对象需要相应修改State ：状态驱动一个对象在其内部状态改变时，改变它的行为记录"状态"：对应一个state子类对象Context 调用Request(),在不同的内部状态下对应不同的行为。每个 ConcreteState对应一个具体的状态。传统方式是采用switch-case语句进行处理的，其问题是：分支过多，而且加入一个新的状态就需要对原来的代码进行编译。State模式下，对这些不同的状态处理进行了封装，当State.Handle()响应处理时，会自动迁移到另一

23、种状态，即状态的切换责任交给了具体的状态类ConcreteState去负责。举例：有限状态自动机(FSM),随着当前状态的不同，对输入有不同的响应。适用情景：对象的行为依赖于其状态，并且该对象必须在运行时根据其状态动态改变其行为Strategy定义一系列的算法，并且使它们可相互替换.本模式使得算法可独立于使用它的客户而变化解析：Strategy中封装了算法的具体实现。Context中存储一个strategy指针，选择执行采用哪个算法。优点：另一种子类化方法在类自身中定义了每一个行为，这样就减少了条件语句更容易扩展模型。在不对应用程序进行代码修改的情况下，使该模式具有新的行为 适用情况：许多相关

24、类只是行为方面有所区别需要算法的不同变体State模式和Strategy 模式在图示上有很多相似的地方，需要说明的是两者的思想都是一致的，只不过封装的东西不 同:State模式封装的是不同的状态，而Stategy 模式封装的是不同的算法.Template method:骨架固定、细节重载定义一个操作中的算法的骨架，而将各步骤的实现延迟到子类中。接口：1) AbstractClass.TemplateMethod():定义算法的骨架2) AbstractClass.PrimitiveOperation():算法各步骤的实现Template模式是采用继承的方式，将算法的轮廓放在抽象基类中，但是算法

25、每一步具体的实现留给了派生类.使得 子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。Template和Strategy解决的是类似的问题。但是 Template模式是采用继承方式，而 Strategy是采取组合的方式Visitor双重分派 当一组具有固定数据结构(比如一个list、或array)的节点需要多种处理能力，且处理能力可扩展。即在 不改变原来类结构(节点)的基础上增加新功能。2)具体访问者角色(Concrete Visitor1)访问者角色(Visitor ):为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了 发送请求给visitor的具体元素

26、角色。这样访问者就可以通过该元素的特定接口直接访问它。):实现每个由访问者角色(Visitor )声明的操作。3)元素角色(Element ):定义一个Accept操作，它以一个访问者为参数。4)具体元素角色(Concrete Element ):实现由元素角色提供的 Accept操作。5)对象结构角色(Object Structure ):这是使用访问者模式必备的角色。它要具备以下特征：能枚举它的元素; 可以提供一个高层的接口以允许该访问者访问它的元素；可以是一个复合(组合模式)或是一个集合，如一个列表或一 个无序集合在Visitor模式中Accept()操作是一个双分派的操作。具体调用哪一

27、个具体的Accept ()操作，有两个决定因素:Element的类型。因为Accept()是多态的操作，需要具体的 Element类型的子类才可以决定到底调用哪一个Accept()实现;Visitor的类型。Accept()操作有一个参数(Visitor* vis),要决定了实际传进来的Visitor的实际类别才可以决定具体是调用哪个VisitConcrete() 实现。在不改变各元素类的前提下定义彳用于这些元素的新操作。VisitorJ模式使得增加新的操作很容易适用情景：Visitor模式适用于数据结构相对稳定的系统(比如一个数组)、官杷数据结构和作用于数据结构匕的操作之间的耦合降低，使得操

28、作可以相对自由地演化.数据结构的每一个结点都可以接受一个访问者的调用，此结点向访问者对象传入结点对象，而访问者对象则反过来执行结点对象的操作讨论:Strategy模式和Template模式实际是实现一个抽象接口的两种方式：继承和组合之间的区别。要实现一个抽象接口，继承是一种方式：我们将抽象接口声明在基类中，将具体的实现放在具体子类中。组合（委托）是另外一种方式：我们 将接口的实现放在被组合对象中，将抽象接口放在组合类中。这两种方式各有优缺点，先列出来：1 ） 继承：优点1 ）易于修改和扩展那些被复用的实现。 缺点1）破坏了封装性，继承中父类的实现细节暴露给子类了；2）白盒”复用，原因在1 ）中

29、；3）当父类的实现更改时，其所有子类将不得不随之改变4）从父类继承而来的实现在运行期间不能改变（编译期间就已经确定了）。 2）组合优点1）黑盒”复用，因为被包含对象的内部细节对外是不可见的；2）封装性好，原因为1 ）;3）实现和抽象的依赖性很小（组合对象和被组合对象之间的依赖性小）；4）可以在运行期间动态定义实现（通过一个指向相同类型的指针，典型的是抽象基类的指针）。 缺点1）系统中对象过多。从上面对比中我们可以看出，组合相比继承可以取得更好的效果，因此在面向对象的设计中的有一条很重要的 原则就是： 优先使用（对象）组合，而非（类）继承（ Favor Composition Over Inhe

30、ritance）。实际上，继承是一种强制性很强的方式，因此也使得基类和具体子类之间的耦合性很强。例如在Template模式中在ConcreteClass1中定义的原语操作别的类是不能够直接复用（除非你继承自AbstractClass ,具体分析请参看Template模式文档）。而组合（委托）的方式则有很小的耦合性，实现（具体实现）和接口（抽象接口）之间 的依赖性很小，例如在本实现中，ConcreteStrategyA的具体实现操作很容易被别的类复用，例如我们要定义另一个Context类AnotherContext，只要组合一个指向 Strategy 的指针就可以很容易地复用 ConcreteS

31、trategyA 的实现了。我们在Bridge模式的问题和Bridge模式的分析中，正是说明了继承和组合之间的区别。请参看相应模式解析。举例：factory method例题：生产洗发水廉*水CLEARClKt ,* Shwnpoc'用走/ producef CL£AR方建I； pfoduc(f HAZE叫 s' )LCl«»,* Shvnpaoe那强上皿B京电 pradix。- ：HA2EUNEHAZEUNtf»rt&ry 0M4 Factory-方法V。卅 w5htmpo。 士堇工厂CLEARfimry ci»

32、71;,* FKtofy-趣 cftJiteShBmipoci&rfa>版Attract l«»对去V crcAtrShdiripGOabstract class Shampoo/抽象的洗发水类public abstract void produce();class HAZELINE : Shampoo / “夏士莲”洗发水，继承抽象洗发水类 public override void produce。 Console.WriteLine(" 夏士莲洗发水")； class CLEAR : Shampoo / “清扬”洗发水，继承抽象洗发水类

33、 public override void produce。 Console.WriteLine(" 清扬洗发水"); abstract class Factory抽象的洗发水工厂类public abstract Shampoo createShampoo();class HAZELINEfactory : Factory / “夏士莲”洗发水工厂，继承抽象洗发水工厂 public override Shampoo createShampoo() Console.Write(" 生产： ");return new HAZELINE();class CLE

34、ARfactory : Factory / “清扬”洗发水工厂，继承抽象洗发水工厂public override Shampoo createShampoo() Console.Write(" 生产： ");return new CLEAR();static void Main (string args)Shampoo shampoo;Factory factory = new HAZELINEfactory();shampoo = factory.createShampoo();duce();factory = new CLEARfactory();

35、shampoo = factory.createShampoo();duce();abstract factory有两个车间，其中一个车间用以生产餐具，一个车间用以生产相应的食物。当消费者消费时，只需要向相应的具体工厂请求具体餐具和具体食物便可以使用餐具消费食物。每个具体工厂生产出来的具体产品根据不同工厂的不同各不相同，但是客户使用产品的方法是一致的。比如客/ 实例化“夏士莲”工厂/ “夏士莲”工厂只创造夏士莲洗发水/ 实例化“清扬”工厂/ “清扬”工厂只创造清扬洗发水3 个具体工厂户在得到餐具和食物之后，两者的搭配是固定的（使用汤匙喝牛奶，使用刀子切面包）。在本例子中有

36、AKitchenBKitchenBKitchen ，分别生产牛奶和汤匙、面包和刀、肉和叉子。Ketch«niFactQfy* S«F«d 0:Fgd*Q Tabl«Ww*AKjetcheni+ gkiTool 0 : Siring-<1 A KARpackage abstractFactory; 02.03.public interfaceKitchenFactory04.05.06.07.08.09. 10.public Food getFood();15.public interfaceTableWare public TableWare ge

37、tTableWare();11 .抽象餐具的接口定义如下所示:12 .13 .package abstractFactory;14 .16.17. public String getTool();18.19. 20.21. 抽象事物的接口定义如下所示:22.23. package abstractFactory;24.25.public interfaceFood 26.27. public String getEatable();28.29. 30.31. 而具体的实现也非常简单，以 AKitchen为例子32.33. 具体工厂AKitchen的定义如下所示；34.35. package a

38、bstractFactory;36.37. public class AKitchenimplements KitchenFactory1.public Food getFood()return new Milk();1. 52.53.54.public TableWare getTableWare()return new Spoon();55. 具体餐具(spoon) 的定义如下所示：56.57. package abstractFactory;58.59. public class Spoonimplements

39、TableWare6.67. 68.public String getTool() return "spoon"69. 具体食物(milk) 的定义如下所示：70.71. package abstractFactory;72.73. public class Milkimplements74.75. public String getEatable()76.77. return "milk"78.79. 80.Food81.82.83. 客户端的定义如下：84.85. package abstractFactory;

40、86.87. public class Client88.89. public void eat(KitchenFactory k)90.91. System.out.println("A person eat "+k.getFood (). getEatable92.93. +" with "+k. getTableWare (). getTool ()+"!");94.95. 96.97. public static void main(String args)98.99. Client client=new Client();1

41、00.101. KitchenFactory kf =new AKitchen();102.103. client.eat(kf);104.()014.115. kf=new BKitchen();client.eat(kf);kf=new CKitchen();client.eat(kf);builder 模式 模拟一个电脑生产、装配的过程：1 ./ 首先是一个建造工具(builder) 接口2 .public interface builder3.4.5.void BuildChassis();/ void Build

42、Kboard();/主机 键盘6.void BuildMonitor();/显示器7.void BuildMouse();/鼠标8.computer getcomputer();/返回产品9.1./建造工具的具体建造方式：implements builder 2.public class ConcreteBuilder3.4.private String Chassis;5.private String Monitor;6.private String Kboard;7.8.private String Mouse;Override9.public void BuildChassis() 10

43、./11.System.out.println("生产主机");12.Chassis= "MAC 主机 "13.14.15.Override16.public void BuildKboard() 17./18.19.System.out.println(" 生产键盘");Kboard= "MAC 键盘 "20.21.22.Override23. public void BuildMonitor() 24. /25. System.out.println("生产显示器")；26. Monitor

44、= "MAC 显示器"27. 28.29. Override30. public void BuildMouse() 31. /32. System.out.println("生产鼠标")；33. Mouse= "MAC 鼠标"34. 35.36. Override37. public computer getcomputer() 38. /39. System.out.println("电脑生产完成")；40. computer c = new computer。；41. c.setJianpan(Kboard)

45、;42. c.setShubiao(Mouse);43. c.setXianshiqi(Monitor);44. c.setZhuji(Chassis);45. return c;46. 47.48. 1.2. public class Director 3.4. privatebuilder builder;5. public Director(builder builder)6. 7. this.builder=builder;8. 9.10. /将零件主机显示器键盘鼠标组成复杂的对象11. /组装电脑的过程12. public void construct。13. 14. builder

46、.BuildChassis();15. builder.BuildMonitor();16. builder.BuildMouse();17. builder.BuildKboard();18. 19. public class computerprivate String Chassis;private String Monitor;private String Kboard;public void setZhuji(String Chassis)public void setXianshiqi(String Monitor)public void setJianpan(String Kbo

47、ard)public void setShubiao(String Mouse)private String Mouse; this.Chassis = Chassis;this.Monitor = Monitor;this.Kboard = Kboard; this.Mouse = Mouse; public void info()System.err.println(String.format("我的配置如下" +", 主机 :%s 显示器：%s 键盘： %s 鼠标 : %s", Chassis,Monitor,Kboard,Mouse);1. pu

48、blic class getcomputer 2.3. public static void main (String args) 4. ConcreteBuilder builder= new ConcreteBuilder();5. Director director = new Director(builder);6. director.construct();7. computer c = builder.getcomputer();8. ();9. 10. singleton 模式 class Singleton:private:Singleton();static Si

49、ngleton * m_pInstance;public:static Singleton * GetInstance()if (m_pInstance = NULL) m_pInstance = new Singleton();return m_pInstance;Bridge 模式生活中的一个例子：就拿汽车在路上行驶的来说。即有小汽车又有公共汽车，它们都不但能在市区中的公路上行驶，也能在高速公路上行 驶。这你会发现，对于交通工具（汽车）有不同的类型，然而它们所行驶的环境（路）也在变化，在软件系统中就要适 应两个方面的变化？怎样实现才能应对这种变化呢？概述：在软件系统中，某些类由于自身的逻辑

50、，它具有两个或多个维度的变化，那么如何应对这种多维度的变化”？如何利用面 向对象的技术来使得该类能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。意图：将抽象部分与实现部分分离，使它们都可以独立的变化。设计模式GOF传统的做法：通过类继承的方式来做上面的例子；先看一下类结构图：所有路的基类 d口 3-方法* Eun高速公路市区中的街道代码实现：1 namespaceCarRunOnRoad2 日3 |/路的基类；4 public class Road59由61 public virtual void Run()7门中8 I Console.WriteLine(

51、"在路上)9 10 I 11 高速公路；12 I public class SpeedWay : Road13=: 14 public override void Run()"局速公路");Console.WriteLine(19 /市区街道；20 I public class Street : Road21 门口 22 I public override void Run()24 l_L Console.WriteLine("市区街道")；25 26 27 /小汽车在高速公路上行驶；28 I public class CarOnSpeedWa

52、y : SpeedWay29 口口 30 Ipublic override void Run()31 口口32 Console.WriteLine("小汽车在高速公路上行驶 ");33 I 34 35 /公共汽车在高速公路上行驶；36 I public class BusOnSpeedWay : SpeedWay37的 n38public override void Run()39的40 Console.WriteLine("公共汽车在高速公路上行驶");41 42 43444546474849505152535455|_I 卜 7|_卜！7 85 55

53、960/小汽车在市区街道上行驶；public class CarOnStreet : Street public override void Run() Console.WriteLine("汽车在街道上行驶")； /公共汽车在市区街道上行驶；public class BusOnStreet : Street public override void Run() Console.WriteLine("公共汽车在街道上行驶 ");客户端调用1 static void Main( string args)/小汽车在高速公路上行驶CarOnSpeedWay Car =new CarOnSpeedWay();Car.Run();6 _7 C