二十三种设计模式类图
0 引言
谈到设计模式，绝对应该一起来说说重构。重构给我们带来了什么？除了作为对遗留代码的改进的方法，另一大意义在于，可以让我们在写程序的时候可以不需事先考虑太多的代码组织问题，当然这其中也包括了应用模式的问题。尽管大多数开发者都已经养成了写代码前先从设计开始的习惯，但是，这种程度的设计，涉及到到大局、到总体架构、到主要的模块划分我觉得就够了。换句话说，这时就能写代码了。这就得益于重构的思想了。如果没有重构的思想，有希望获得非常高质量的代码，我们就不得不在开始写代码前考虑更多其实并非非常稳定的代码组织及设计模式的应用问题，那开发效率当然就大打折扣了。在重构和设计模式的合理应用之下，我们可以相对较早的开始写代码，并在功能尽早实现的同时，不断地通过重构和模式来改善我们的代码质量。所以，下面的章节中，在谈模式的同时，我也会谈谈关于常用的这些模式的重构成本的理解。重构成本越高意味着，在遇到类似的问题情形的时候，我们更应该提前考虑应用对应的设计模式，而重构成本比较低则说明，类似的情形下，完全可以先怎么方便，怎么快怎么写，哪怕代码不是很优雅也没关系，回头再重构也很容易。
1 创建型
1.1FactoryMethod
思想：Factory Method的主要思想是使一个类的实例化延迟到其子类。
场景：典型的应用场景如：在某个系统开发的较早阶段，有某些类的实例化过程，实例化方式可能还不是很确定，或者实际实例化的对象（可能是需要对象的某个子类中的一个）不确定，或者比较容易变化。此时，如果直接将实例化过程写在某个函数中，那么一般就是if-else或select-case代码。如果，候选项的数目较少、类型基本确定，那么这样的if-else 还是可以接受的，一旦情形变得复杂、不确定性增加，更甚至包含这个构造过程的函数所
在的类包含几个甚至更多类似的函数时，这样的if-else代码就会变得比较不那么容易维护了。此时，应用本模式，可以将这种复杂情形隔离开，即将这类不确定的对象的实例化过程延迟到子类。
实现：该模式的典型实现方法就是将调用类定义为一个虚类，在调用类定义一个专门用于构造不确定的对象实例的虚函数，再将实际的对象实例化代码留到调用类的子类来实现。如果，被构造的对象比较复杂的话，同时可以将这个对象定义为可以继承、甚至虚类，再在不同的调用类的子类中按需返回被构造类的子类。
重构成本：低。该模式的重构成本实际上还与调用类自己的实例化方式相关。如果调用类是通过Factory方式（此处“Factory方式”泛指对象的实例化通过Factory Method或Abstract Factory这样的相对独立出来的方式构造）构造的，那么，重构成本相对就会更低。否则，重构时可能除了增加调用类的子类，还要将所有实例化调用类的地方，修改为以新增的子类代替。可能这样的子类还不止一个，那就可以考虑迭代应用模式来改善调用类的实例化代码。
1.2AbstractFactory
思想：不直接通过对象的具体实现类，而是通过使用专门的类来负责一组相关联的对象的创建。
场景：最典型的应用场景是：您只想暴露对象的接口而不想暴露具体的实现类，但是又想提供实例化对象的接口给用户；或者，您希望所有的对象能够集中在一个或一组类（通常称作工厂类）来创建，从而可以更方便的对对象的实例化过程进行动态配置（此时只需要修改工厂类的代码或配置）。
实现：该模式的实现是比较清晰简单的，如上图，就是定义创建和返回各种类对象实例的工厂类。在最复杂而灵活的情形，无论工厂类本身还是被创建的对象类都可能需要有一个继承体系。简单情形其实可以只是一个工厂类和需要被创建的对象类。不一定非要像上图中结
构那么完备（累赘）。
重构成本：中。如果一开始所有的对象都是直接创建，例如通过new实例化的，而之后想重构为Abstract Factory模式，那么，很自然的我们需要替换所有直接的new实例化代码为对工厂类对象创建方法的调用。考虑到像Resharper这样的重构工具的支持，找出对某个方法或构造函数的调用位置这样的操作相对还是比较容易，重构成本也不是非常高。同时，重构成本还和被创建对象的构造函数的重载数量相关。您需要根据实际情况考虑，是否工厂类要映射被创建对象的所有重载版本的构造函数。
1.3Builder
思想：将一个类的创建过程和他的主体部分分离。
场景：该模式的典型的应用场景是：一个类的创建过程可能比较复杂，或者创建过程中的某些阶段可能会容易变化；或者多个类的创建过程比较类似，但是主体不同。
实现：在以上提到的两种场景中，我们就可以取出一个类的创建过程的代码，定义一个专门的Builder类，而在原来创建类对象实例的地方，将这个Builder类的实例作为参数传入。还有第二个重点，就是Builder类可以将将整个创建过程分为几个阶段，每个阶段不必在类中直接实现，而可以通过继承体系在子类中实现，或者通过子类的方法过载来修改创建过程中的某个阶段，但是重用其他的阶段。可以发现，该模式将一个对象的复杂创建过程重用到非常高的层次。这正是它的意义所在。
重构成本：低。该模式的重构成本我觉得是非常低的，因为一般来讲，创建过程的代码本来也就应该在原来的类的构造函数中，把它Extract出来就好了。如果发现多个类的创建过程有比较多的代码重复或类似，那么就可以重用这些提取出来的Builder类或者Builder类中的某些阶段。
1.4Prototype
思想：克隆一个已有的类的实例（大家相比都用过甚至写过类的Clone实现，应该很容易理解了）。
场景：应用Clone的场景应该说非常多，理想情况下我当然希望任何类都能Clone，需要的时候就能Clone一份一模一样的出来。
实现：这里将的实现主要之实现的表现形式，而不是如何用具体的语言来实现。因此，只要为需要Clone能力的类定义一个Clone方法就行。当然，一般，主流的程序语言框架都已经定义了通用的Clone接口（当然也可以自己定义），继承并实现该接口和方法就好。重构成本：极低。不多解释了吧。
1.5 Singleton
思想：保证一个类只有一个唯一的实例。
场景：生活中有些对象就是只要一个就好了，我们的代码中为什么要每次都为这样的对象生成一个实例呢？
实现：最简单的实现方式就是使用一个static型的类实例，每次对该对象的创建请求都返回这个static的唯一实例就行。
重构成本：极低。
2 结构型
2.1Adapter
思想：将一个类的接口转换成另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
场景：该模式的应用场景太多了，很多需要的功能模块的接口和我们需要的不完全一致或者有多余或不足，但是需要和我们的系统协同工作，通过Adapter把它包装一下就能让使它接口兼容了。
实现：定义一个Adapter类，包含需要包装的类，实现需要的其它接口，调用被包装的类的方法来实现需要的接口。
重构成本：低。
2.2Bridge
思想：将一个类的抽象定义和具体实现解耦。
场景：该模式的典型应用场景是：一个类的抽象定义已经确定，但是，其实现代码甚至原理可能会不同。比如：我们最熟悉的图形界面中的window的实现，无论在什么操作系统，什么平台的机器上，一个window应具有的抽象定义基本上是一致的，但是，其实现代码肯定会因为平台不同，机器的代码指令不同而不同。此时，如果希望您写的window类能跨平台，应用Bridge模式就是一个好主意。
实现：该模式的实现方法很简单，就是除了定义类的抽象定义之外，将一个类的所有实现代码独立出一个实现类。这样一来，无论是抽象定义还是实现类都能分别修改和重用，但只要两部分的交互接口不变，还是可以方便的互相组装。当然，实际上也没有必要隔离出“所有实现代码”，只需要隔离需要的部分就行了。因此，也可以说，从代码结构来看，Builder 模式是一种变种的Bridge模式的。也经常有人将Bridge模式和接口相比较，如果隔离出所有的实现，那么的确接口的方式也能做到抽象定义和实现分离，但是，Bridge有其优势如下：一、究竟隔离多少代码到Bridge类中可以灵活确定，二、减少了总的类的数目，三、允许被隔离出来的Bridge类被其它的类直接共享使用。
重构成本：中。将所有的（或很大部分）实现代码分离开来总还是一件不大，但是，也不小的事。所以标个“中”在这里。：）
2.3Composite
思想：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
场景：该模式的应用场景极其类似，比如像图形系统，如电路设计、UML建模系统，或者
像web的显示元素等，都是那种需要整体和部分具有使用接口上的一定的一致性的需求的结构，实际上，我觉得这样的系统如果不使用Composite模式将会是惨不忍睹的。
实现：该模式的实现主要就是要表示整体或部分的所有类都继承自同一的基类或接口，从而拥有使用接口上一定的一致性。
重构成本：高。
2.4Decorator
思想：为一个对象已有的子类添加一些额外的职责。
场景：该模式的使用场景，主要是有的时候我们不愿意定义逻辑上新的子类，因为没有新的逻辑含义上的子类概念，而只是想为一个已存在的子类附加一些职责。
实现：该模式的实现主要就是定义一个物理上的新的子类，但是，它只是包含要附加职责的类，传递外部对相同接口的调用，在这个传递调用的通道上附加额外的功能。突然想到，Decorator模式是不是一定程度上也能代替DynamicProxy模式，从而成为一种AOP实现的方案呢？
重构成本：低。定义一个Decorator和一个已有类的逻辑上的子类，物理表现形式上都是一个子类，重构也确实不是难事。
2.5 Facade
思想：为子系统中的一组接口提供一个一致的界面，这个接口使得这一子系统更加容易使用。场景：当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过Facade层。客户程序与抽象类的实现部分之间存在着很大的依赖性。引入Facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。当你需要构建一个层次结构的子系统时，使用Facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过Facade进行通讯，从而简化了它们之间的依赖关系。（这里直接引用了《设计模式迷你手册》，因为觉得它确实已经说得很明了了，下面类似的情形我直接引用原文的就不再注明了，这里先说明一下，感谢《手册》作者的这些优秀总结。当然，本文的绝大多数文字都是Teddy本人的原创看法，绝非抄袭，您可以比较本文和附件《手册》，附件同时也会提供本文的Word版本下载。）实现：该模式的实现需要定义一个新的系统构架上的Layer，该层向上提供一组新的接口，向下调用子系统原有的接口。
重构成本：高。要修改所有直接对子系统的地调用为对Fa?ade层的调用还是有很多事情要做的。不过，现代IDE中，如果我们删除调用层对子系统的程序集引用，那么所有这些我们需要修改的调用都能标示出来，因为编译不能通过了嘛，因此，重构的风险还不算特别大，只是工作量着实不小。
2.6Flyweight
思想：说Flyweight可能有的朋友第一次看到想象不到是什么样子，其实说他就是一个Pool，你可能就明白了。也就是由一个Flyweight Factory来管理一族一定数目逻辑上经常需要构建和销毁的细颗粒对象，例如我们常见的数据库连接池。在Factory内部，并不物理销毁这些对象，而在接到实例化请求时返回这些被关系对象的实例，从而减少创建销毁这些细颗粒对象的开销。
场景：基本上所有的需要Pool这个概念的环境都能应用。
实现：实现的底层方式可以千变万化，在接口上就是如上图所示，花样不多。这里就不多解释。
重构成本：低。
2.7Proxy
思想：前面在Decorator模式中也提到了Proxy模式了。它是通过逻辑上继承一个已有类
的子类，从而扩展原有的子类的功能。
场景：需要注意体会他和Decorator的需别。Proxy是继承需要修饰的类，而Decorator用的是包含的方式。Proxy模式，或者准确地说DynamicProxy模式，是现代AOP框架实现中的一种常用方式。典型的实现如Spring，JBoss以及Castle Project中的Aspect#。
实现：继承，并在过载方法中添加需要的修饰功能。
重构成本：低。
3 行为型
3.1 Interpreter
思想：当有一个语言需要解释执行, 并且你可将该语言中的句子表示为一个抽象语法树时，定义一个解释器，这个解释器使用该表示来解释语言中的句子。
场景：其实，从物理结构上，该模式的代码架构看起来可能和Composite模式一模一样，致使其针对的逻辑语义不同。Composite模式描述一种一般的整体和部分使用接口上的一致性，而Interpreter模式则侧重于语言解释器的实现构架。
实现：如上图，基本同Composite模式。
重构成本：高。
3.2Iterator
思想：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。场景：访问一个聚合对象的内容而无需暴露它的内部表示。支持对聚合对象的多种遍历。为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
实现：其实就是定义一个逻辑上类似一个指针的迭代类。专门用于这种迭代工作。如果对C++ STL火锅功夫学习的朋友一定不会陌生啦。实际使用过一下就明白了。除了功能之外，他给我最大的感受就是他让我熟悉的for(int i = 0; i < list.Count; i++)语句，变长了好多。^-^ 重构成本：中。
3.3Mediator
思想：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
场景：该模式主要用来进行降低一组相互关联调用的对象间的耦合度。如果您发现您的系统的某部分的一组对象间调用极其频繁的坏味道的话，可能您需要考虑使用该模式来进行一些解耦，否则，这些对象中的任何一个的修改，都将可能导致其他对象许多地方的修改，可维护性就降低了。
实现：定义一个专门的中介对象来封装和传递一组对象间的调用。
重构成本：中。
3.4Memento
思想：用在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
场景：该模式主要用来实现类似我们在常见的编辑器中经常执行的Undo（Ctrl+Z）操作。实际上就是在外部保持一组对象的某一时刻的状态，并在需要的另一个时候将这组对象回复到之前的状态。
实现：该模式其实主要是一种对象状态的暂存和回复的思想。上面的UML图是一种比较典型的实现方式——定一个专门用于保存类状态的类，为被保存状态的类定义返回当前状态类实例，和根据状态类实例回复对象状态的接口。实际上也不必太拘泥于这个实现，简单情形下，我们完全可以利用任何的已有的对象持久化或者序列化机制来用一个字符串暂存对象的当前完整状态。
重构成本：低。
3.5 Template Method
思想：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Te m p l a t e M e t h o d 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
场景：该模式实际上是一种非常直观和可理解的OO思想下的代码重用的实现。只需一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。模板方法只允许在特定点计算法的某个阶段被过载，这样也就只允许在这些点进行扩展。
实现：见上图，太简单了，就不多说了。
重构成本：低。
3.6 Chain of Responsibility
思想：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
场景：该模式实际上是对人们常会不自觉地去做的一种代码组织方式的总结而已。有的时候一条消息需要被处理，我们当然可以在一个雷的一个方法中对他进行所有需要的处理。但是，如果要做的处理很复杂的情形，甚至能够按照一定的逻辑醒来分类所有这些处理，则不要在一个雷一个函数里处以一切会更好，我们可以定义多个处理类类表示逻辑上的不同的处理，然后一个个处理类的传递这个消息对象，让希望处理该消息的类自己决定是不是要处理。这样，就能将一个难以维护的复杂处理过程，分解为一系列简单明了，易于维护的类了。
实现：上图是实现方式之一。即，使所有可能处理该请求的对象继承自一个基类，实际上，只要逻辑语义上我们保持这样一种让每个处理类自己决定何时处理，并传递请求的思想，实现方式也可以千变万化，无论是用接口代替，或者甚至只是简单的定义相同结构的处理函数而通过反射机制来调用处理函数和传递处理请求，都是可选的方案。
重构成本：中。
3.7Command
思想：将一个动态的执行过程封装成一个对象，可以像处理数据来处理和管理这样的对象，在需要的时候激发该对象的方法就能执行被封装的执行过程。
场景：该模式在很多时候非常有用，它使得我们对逻辑上已经激发的行为进行优化成为可能，我们不仅可以根据需要改变一组逻辑上以经济法的活动的顺序，消冗余操作，撤销不必要的操作等。也可以把活动和操作视为资源一样来管理和重用。同时该模式也是许多事务处理机制的基础。
实现：实现很简单，只是定义一些能够通过指定接口被激发的对活动进行封装的类，然后我们按照需要管理这些类，并在需要的时候激发这些活动。您还是应该更多地去体会，为什么他是事务处理机制的基础，当我们可以这样来管理一组活动的时候，可以对这些活动进行那些有趣的控制。
重构成本：高。
3.8Observer
思想：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
场景：上面描述该模式思想的文字可能显得有些拗口，实际上你也不用想得过于复杂。只要你写过任何的基于图形界面的程序，那么实际上您对他是一点也不该陌生的。它就是我们
每一次鼠标键盘敲击都在我们的程序内部流转着的事件机制的基础。当一个事件发生，则通知订阅该事件的对象。
实现：上面的UML图看似复杂，实际上，去理解它的最好的办法就是试着思考和使用任何一种OO语言来定义一个拥有事件机制的类。比如，.Net下，你只要好好去看看关于delegate的文档，尝试着根据MSDN写写看一个最简单的自定义事件。那么，上面的UML 图，我敢保证你能很轻易的看明白。
重构成本：高。
3.9 State
思想：允许一个对象在其内部状态改变时改变它的行为。
场景：实际上该模式在作为重构的目的是，绝大多数情况我们做的事情是将对一个类的state 进行if-else或者select-case，决定该执行什么操作的过程解耦的过程。
实现：将表述一个类的某些操作该做什么，该怎么做的信息保存到其state中。即用一个包含更多信息，甚至执行逻辑的state类实例来代替一个简单数据类型的state属性。
重构成本：中。
3.10Strategy
思想：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
场景：该模式实际上也可以理解为一种Bridge模式的变种。只是它突出的是，一般当我们把一个类或者一组类的一些代码独立成一个Strategy类的时候，我们可能会为同样接口的
这些算法定义多个接口一致，但是实现方法不同的版本，并在需要的时候灵活的替换这些算法。
实现：实现方式同Bridge模式。
重构成本：中。
3.11Visitor
思想：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
场景：其实你不用去理解上面这句话。该模式其实又是一个在代码的物理结构上和Bridge 模式很相似的模式。但是，其语义，其目的，在逻辑上又是不同的。如果说Bridge，以及上述我称为可视为Bridge扩展的模式中，作为参数的Bridge类，是作为调用类的被访问对象的话，Visitor，在大多数情形下，如其英文含义，它在语义上是完全相反的。不是他被调用的类处理，更大程度上它处于主动状态，是它去访问，去处理调用它的类。调用它的类，把自己对别人隐藏起来的东西，暴露给Visitor品尝，任君蹂躏（这个，这个~~千万别想歪了;-））。另一方面，即使逻辑上没有这种Visitor主动去访问调用类的语义，只要Visitor类中的操作，是依赖于调用类的具体实现类（它本身或他某个层次的子类）的某些状态或者方法的，那么，就可以应用该模式来分离出这样的可重用的操作。
实现：类似Bridge模式。重构成本：中。
软件概要设计说明书 (1) 1．概述 (1) 1.1 软件设计目标 (1) 1.2 参考资料 (2) 2 术语表 (2) 3 用例 (2) 4 设计概述 (3) 4.1简述 (3) 4.2系统结构设计 (3) 4.1.1 物理模型： (3) 4.1.2 软件功能结构图： (4) 4.3系统层次划分 (5) 4.4设计用况的类图、顺序图 (6) 4.4.1市民上报问题 (6) 4.4.2上级下达命令 (10) 4.4.3街乡二级平台上报问题 (14) 4.4.4（监督员）登记问题（接线员上报问题） (17) 4.4.5值班长核查问题 (20) 4.4 约束和假定 (24) 5 非功能性需求 (24) 软件概要设计说明书 1．概述 本说明书主要描述朝阳区城市网络化管理信息系统的子系统的各个模块的设计；包括登录模块，登记问题模块，市民上报问题模块，上级下达命令模块，街乡二级平台上报问题模块，核查问题模块，以及立案模块。将针对上述模块的功能进行面向对象的分析并完成相应用例的顺序图，相应对象的状态图的设计以及系统总体构架和配置。对系统的性能，可用性等非功能需求也有相应描述，供详细设计人员和项目小组以及用户参考。 1.1 软件设计目标 我国数字城市技术应用现已逐渐应用到社会的各个领域中。为了节约大量的人力、物力、财力。网格管理新模式的提出将解决人们一串串“投诉没门路、解决无期限”的烦恼。 本系统主要实现朝阳区城市网络化管理信息系统中的信息提交子系统功能。具体针对各个模块进行概要设计，模块化结构更清晰。
1.2 参考资料 中华人民共和国国家标准：《城市市政监管信息系统技术规范》； 《城市市政监管信息化部件和事件分类与编码》； 《城市市政监管信息化单元网格划分与编码》； 《城市市政监管信息化地理编码》； 《软件需求规格说明书》 2术语表 UML 统一建模语言 3用例 系统顶级用例图：
UML设计模式考试题 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。 该模式中包含的角色及其职责 工厂（Creator）角色 简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。 抽象（Product）角色 简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。 具体产品（Concrete Product）角色 简单工厂模式的特点: 简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。 在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。 请问什么是责任链器模式，责任链模式包含哪些角色、可以应用在哪些场景？定义：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。角色：处理者、具体处理者。场景：有许多对象可以处理用户的请求，希望程序在运行期间自动确定处理用户的那个对象；希望用户不必明确指定接受者的情况下，向多个接受者一个提交请求；程序希望动态指定可处理用户请求的对象集合 设计模式六大原则-单一职责原则、开放封闭原则、依赖倒转原则、里氏代换原则、迪米特法则、合成/聚合复用原则 标签：扩展编程设计模式class测试工作 2012-07-31 09:26 1823人阅读评论(0) 收藏举报 分类：OO（1） 原则，故名思议则是本质的意思。所谓擒贼先擒王，研究设计模式自然要先了解设计原则，所有的模式都是在这些原则的基础之上发展起来的，有的是侧重一个，有的是多个都有所涉及。看完设计模式之后，我感觉到每个模式都有这些原则的影子，还渗透着面向对象的三大属性，也觉得这些原则也都有相通之处，，正是有了他们才使我们由代码工人转为艺术家。下面我来点评一下六大原则，望各位拍砖： 1、单一职责原则（Single Responsibility Principle，简称SRP） 单一职责原则，就一个类而言，应该仅有一个引起它变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会消弱或者一直这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破
创建型结构型行为型 类Factory Method Adapter In terpreter Template Method 对象 Abstract Factory Builder Prototype Si ngleto n Apapter(对象) Bridge Composite Decorator Fa?ade Flyweight Proxy Chain of Resp on sibility Comma nd Iterator Mediator Meme nto Observer State Strategy Visitor （抽象工厂） 提供一个创建一系列相关或互相依赖对象的接口，而无须制定它们具体的类。 图10-25抽象工厂模式结构图 Abstract Factory 抽象工厂 class Program { static void Main(string[] args) { AbstractFactory factory1 = new Con creteFactory1(); Clie nt c1 = new Clie nt(factory1); c1.Ru n(); AbstractFactory factory2 = new Con creteFactory2(); Clie nt c2 = new Clie nt(factory2); c2.Ru n(); Co nsole.Read(); abstract class AbstractFactory { public abstract AbstractProductA CreateProductA(); public abstract AbstractProductB
软件概要设计说明书类 图顺序图 YUKI was compiled on the morning of December 16, 2020
软件概要设计说明书................................... 错误!未定义书签。1．概述.......................................... 错误!未定义书签。 软件设计目标 ................................ 错误!未定义书签。 参考资料 .................................... 错误!未定义书签。2术语表............................................ 错误!未定义书签。3用例.............................................. 错误!未定义书签。4设计概述.......................................... 错误!未定义书签。 简述............................................. 错误!未定义书签。 系统结构设计..................................... 错误!未定义书签。 物理模型：............................. 错误!未定义书签。 软件功能结构图：....................... 错误!未定义书签。 系统层次划分..................................... 错误!未定义书签。 设计用况的类图、顺序图........................... 错误!未定义书签。 市民上报问题................................. 错误!未定义书签。 上级下达命令................................. 错误!未定义书签。
23种设计模式UML 类图及对应示例代码(一) 收藏 1.DoFactory.GangOfFour.Abstract.Structural Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 using System; namespace DoFactory.GangOfFour.Abstract.Structural { ///
class MainApp { ///
23种设计模式趣味讲解 对设计模式很有意思的诠释，呵呵，原作者不详。 创立型模式 1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，固然口味有所不同，但不管你带MM往麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类离开。花费者任何时候需要某种产品，只需向工厂恳求即可。花费者无须修正就可以接纳新产品。毛病是当产品修正时，工厂类也要做相应的修正。如：如何创立及如何向客户端供给。 2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同处所的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM 我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这必定比美军在伊拉克用的翻译机好卖） 建造模式：将产品的内部表象和产品的天生过程分割开来，从而使一个建造过程天生具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变更，客户不必知道产品内部组成的细节。建造模式可以强迫履行一种分步骤进行的建造过程。 3、FACTORY METHOD—请MM往麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。 工厂方法模式：核心工厂类不再负责所有产品的创立，而是将具体创立的工作交给子类往做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的串口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE—跟MM用QQ聊天，必定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要） 原始模型模式：通过给出一个原型对象来指明所要创立的对象的类型，然后用复制这个原型对象的方法创立出更多同类型的对象。原始模型模式容许动态的增加或减少产品类，产品类不需要非得有任何事先断定的等级结构，原始模型模式实用于任何的等级结构。毛病是每一个类都必须配备一个克隆方法。 5、SINGLETON—俺有6个美丽的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，
注：班里的可以向我要工程文件 实验一设计模式综合应用（一） 一、实验目的： 熟练掌握Java设计模式中的命令模式和观察者模式，并培养学生将两者综合应用到具体软件项目中的能力。 二、实验内容： 制作如图1所示GUI界面，需求如下： 1. 鼠标左键点击界面时，在鼠标所在位置填充一个直径为20像素的圆， 并在界面上方的标签上显示“新增圆点位于：(x,y)”； 2. 鼠标右键点击时，则实现undo操作，将最后填充的圆点从界面中删除， 并在界面上方的标签上显示“删除圆点位于：(x,y)”； 3. 界面下方的标签随时显示“鼠标位于：(x,y)”； 图1 GUI界面 三、实验要求： 1. 绘制和撤销圆点使用命令模式； 2. 两个标签内容的变更使用观察者模式； 3. 在代码实现之前，进行UML类图设计；
4. 根据UML类图，在eclipse中编程实现程序的功能。 四、实验学时：2+2学时（课外2个学时） 五、提示： 1．设计一个Circle类，该类对象用来记录某个填充圆的信息； 2. 每填充一个圆点，就实例化一个Circle类对象，并将其放置到具体命令对 象关联的List对象中，用来作为undo操作的依据； 3. 填充圆可以使用Graphics的fillOval方法； 4. 删除圆可以先将Graphics对象的颜色设置为画布的背景色，再使用 Graphics的fillRect方法； 5. 标签显示内容的需求不用观察者模式就可以轻松实现，但要求使用观察者 模式进行设计； 5. 实验完成后，将UML文件和程序的工程文件打包，命名为“实验一.rar”， 并上传至ftp://10.10.3.72。 六UML图 七源代码 1. package lsu.egg.sy1; public class Circle { private int x; private int y;
二十三种设计模式类图 0 引言 谈到设计模式，绝对应该一起来说说重构。重构给我们带来了什么？除了作为对遗留代码的改进的方法，另一大意义在于，可以让我们在写程序的时候可以不需事先考虑太多的代码组织问题，当然这其中也包括了应用模式的问题。尽管大多数开发者都已经养成了写代码前先从设计开始的习惯，但是，这种程度的设计，涉及到到大局、到总体架构、到主要的模块划分我觉得就够了。换句话说，这时就能写代码了。这就得益于重构的思想了。如果没有重构的思想，有希望获得非常高质量的代码，我们就不得不在开始写代码前考虑更多其实并非非常稳定的代码组织及设计模式的应用问题，那开发效率当然就大打折扣了。在重构和设计模式的合理应用之下，我们可以相对较早的开始写代码，并在功能尽早实现的同时，不断地通过重构和模式来改善我们的代码质量。所以，下面的章节中，在谈模式的同时，我也会谈谈关于常用的这些模式的重构成本的理解。重构成本越高意味着，在遇到类似的问题情形的时候，我们更应该提前考虑应用对应的设计模式，而重构成本比较低则说明，类似的情形下，完全可以先怎么方便，怎么快怎么写，哪怕代码不是很优雅也没关系，回头再重构也很容易。 1 创建型 1.1FactoryMethod 思想：Factory Method的主要思想是使一个类的实例化延迟到其子类。 场景：典型的应用场景如：在某个系统开发的较早阶段，有某些类的实例化过程，实例化方式可能还不是很确定，或者实际实例化的对象（可能是需要对象的某个子类中的一个）不确定，或者比较容易变化。此时，如果直接将实例化过程写在某个函数中，那么一般就是if-else或select-case代码。如果，候选项的数目较少、类型基本确定，那么这样的if-else 还是可以接受的，一旦情形变得复杂、不确定性增加，更甚至包含这个构造过程的函数所
Gof的23种设计模式 从2005年初听说设计模式，到现在虽然已经8年多了，但GoF的23种模式依然盛行，当然GoF提出这些模式的 年代更加久远（1995年）。在工作的过程中，陆陆续续接触了GoF的大部分模式，我记得在2008年的时候就想总结一下设计模式（最近想做的两件事情），最后因为各种原 因也没有完成。最近这段时间正好是职业空档期，没什么事儿做，就把之前看过的设计模式翻出来整理了一下，于是就有了上面几篇文章。整理设计模式的过程，也是一个深刻理解面向对象设计的过程。通过对各个模式的回顾，让我更能够明白前辈们关于面向对象设计提出的各种“最佳实践”，特别是S.O.L.I.D，我觉得在这里再说一次，也不算矫情。S：单一职责原则（Single Responsibility Principle, SRP），一个类只能有一个原因使其发生改变，即一个类只承担一个职责。 O：开放-封闭原则（Open-Close Principle, OCP），这里指我们的设计应该针对扩展开放，针对修改关闭，即尽量以扩展的方式来维护系统。 L：里氏替换原则（Liskov Subsititution Principle, LSP），它表示我们可以在代码中使用任意子类来替代父类并且程 序不受影响，这样可以保证我们使用“继承”并没有破坏父类。
I：接口隔离原则（Interface Segregation Principle, ISP），客户端不应该依赖于它不需要的接口，两个类之间的依赖应该建立在最小接口的基础上。这条原则的目的是为了让那些使用相同接口的类只需要实现特定必要的一组方法，而不是大量没用的方法。 D：依赖倒置原则（Dependence Inversion Principle, DIP），高层模块不应该依赖于低层模块，两者应该都依赖于抽象；抽象不依赖于细节，而细节应该依赖于抽象。这里主要是提倡“面向接口”编程，而非“面向实现”编程。设计模式，从本质上讲，是针对过去某种经验的总结。每种设计模式，都是为了在特定条件下去解决特定问题，离开这些前提去讨论设计模式，是没有意义的。下面，我们快速回顾GoF的23种模式。工厂方法 意图：定义一个用户创建对象的接口，让子类去决定具体使用哪个类。 适用场合：1）类不知道它所要创建的对象的类信息；2）类希望由它的子类来创建对象。抽象工厂 意图：提供一个创建一系列相关或者相互依赖的对象的接口，而无须指定它的具体实现类。 适用场合：1）系统不依赖于产品是如何实现的细节；2）系统的产品族大于1，而在运行时刻只需要某一种产品族；3）属于同一个产品族的产品，必须绑在一起使用；4）所有的
UML选择题
-、选择题 1.封装是指把对象的(A)结合在一起,组成一个独立的对象。 A. 属性和操作 B.信息流 c.消息和事件 D.数据的集合 2.封装是一种(C)技术,目的是使对象的生产者和使用者分离,使对象的定义和实現分1开。 A. 」_程化 B.系统维护 C.信息隐敞 D.产生对象 3.面向对象方法中的(D)机制使子类可以自动地例有(复制)父类全部属性和操作。 A.约東 B.对象映射 c.信息隐蔽 D.继承 4.在c++中,使得在多个类中能够定义同一个操作或属性名,并在每一个类中有不同的实現的一种方法是(B)。 A.继承 B.多态性 C.约束 D.接口 1.UML的软件开发以(A)为中心,以系统体系结构为主线,采用循环、迭代、渐增的方式进
行开发。 A.用例 B.对象 C.类 D.程序 2.uML的(B)模型图由类图、对象图、包图、构件图和配置图组成。 A.用例 B.静态 C.动态 D.系统 3.uML的(c)模型图由活动图、顺序图、状态图和协作图组成。 A.用例 B.静态 C.动态 D.系统 4.UML的最终产物就是最后提交的可执行的软 件系统和(D)。 A.用户手册 B.类图 C.动态图 D.相应的软件文档资料 5.在u ML的需求分析建模中,(B)模型图必 须与用户反复交流并加以确认。 A.配置 B.用例 C.包 D.动态 1.可行性研究分析包括经济可行性分析、技术可行性分析和(B)。
A.风险可行性分析 B.法律可行性分析 c.资源可行性分析 D.效益可行性分析 2.uML的客户需求分析模型包括(A)模型、初始类图、初始对象图和活动图组成。 A.用例 B.静态 C.动态 D.系统 3. uML客.J·?需求分析使用的 CRC卡上“责任”一栏的内容主要描述类的( C )和操作。 A.对象成员 B.关联对象 C.属性 D.私有成员 4.uML客户需求分析产生的用例模型描述了系 统的(D)。 A.状态 B.体系结构 c.静态模型 D.功能要求 5.在u ML的需求分析建模中,用例模.型必须与 (D)反复交流并加以确认。 A.软件生产商 B.用户单位领导 C.软件开发人员 D.问题领域专家 6.在u ML的需求分析建模中,对用例模.型中的 用例进行细化说明应使用(A)《图一>文字一>
返回总目录
目 录
第 10 章 UML 与设计模式 ...................................................................................2 10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 10.9 10.10 10.11 什么是模式 ................................................................................................2 为什么要使用设计模式 ............................................................................3 模式的分类 ................................................................................................4 模式的组成元素 ........................................................................................6 模式的质量 ................................................................................................7 一个简单的模式例子 代理模式 ............................................................8 UML 对模式的支持 ..................................................................................9 应用设计模式进行系统设计 ..................................................................14 模式选择举例 评估项目 ......................................................................15 模式应用举例 形状编辑器 ................................................................20 小 结 ..................................................................................................36
总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下： 二、设计模式的六大原则 1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。 2、里氏代换原则（Liskov Substitution Principle） 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科 3、依赖倒转原则（Dependence Inversion Principle） 这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。 4、接口隔离原则（Interface Segregation Principle） 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。 5、迪米特法则（最少知道原则）（Demeter Principle） 为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。 6、合成复用原则（Composite Reuse Principle） 原则是尽量使用合成/聚合的方式，而不是使用继承。 三、Java的23中设计模式 从这一块开始，我们详细介绍Java中23种设计模式的概念，应用场景等情况，并结合他们的特点及设计模式的原则进行分析。 1、工厂方法模式（Factory Method） 工厂方法模式分为三种：
工厂模式在《Java与模式》中分为三类： 1）简单工厂模式（Simple Factory）：不利于产生系列产品； 2）工厂方法模式（Factory Method）：又称为多形性工厂； 3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品； 这三种模式从上到下逐步抽象，并且更具一般性。 GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Metho d）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。 二、简单工厂模式 简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。 先来看看它的组成： 1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。 2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。 3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 三、工厂方法模式 工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。 来看下它的组成： 1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类
设计模式概念：一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。设计模式要素：模式名称、问题、举例、末态环境、推理、其他有关模式、已知的应用。设计模式分类：创建型、结构型、行为型。 创建型模式功能：1.统所使用的具体类的信息封装起来； 2.类的实例是如何被创建和组织的。 创建型模式作用：1.封装创建逻辑，不仅仅是new一个对象那么简单。 2.封装创建逻辑变化，客户代码尽量不修改，或尽量少修改。 常见的创建型模式：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。常见的结构型模式：代理模式、装饰模式、适配器模式、组合模式、桥梁模式、外观模式、享元模式。 常见行为型模式：模板方法模式、命令模式、责任链模式、策略模式、迭代器模式、中介者模式、观察者模式、备忘录模式、访问者模式、状态模式、解释器模式。单一职责原则：一个类应该只有一个职责。 优点：降低类的复杂性；提高类的可读性；提高代码的可维护性和复用性；降低因变更引起的风险。 里氏替换原则： 优点：代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；提高代码的可重用性；提高代码的可扩展性；提高产品或项目的开放性。 缺点：1.继承是入侵式的。只要继承，就必须拥有父类所有属性和方法。 2.降低代码的灵活性。子类必须拥有父类的属性和方法，使子类收到限制。 3.增强了耦合性。当父类的常量、变量和方法修改时，必须考虑子类的修改，这种 修改可能造成大片的代码需要重构。 依赖倒置原则：高层模块不应该依赖低层模块，两者都依赖其抽象；抽象不依赖细节；细节应该依赖于抽象。 在Java中的表现：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；接口或抽象类不依赖于是实现类； 实现类依赖于接口或抽象类。 接口隔离原则：1.一个类对另外一个类的依赖性应当是建立在最小的接口上的 2.一个接口代表一个角色，不应当将不同的角色交给一个接口。 3.不应该强迫客户使用它们的不同方法。 如图所示的电子商务系统在三个地方会使用到订单类：一个是门户，只能有查询方法；一个是外部系统，有添加订单的方法；一个是管理后台，添加、删除、修改、查询都要用到。“原子”在实践中的衡量规则： 1.一个接口只对一个子模块或者业务逻辑进行分类。 2.只保留接口中业务逻辑需要的public方法。 3.尽量修改污染了的接口，若修改的风险较大，则可采用适配器模式进行转化处理。 4.接口设计应因项目而异，因环境而异，不能照搬教条。 迪米特法则：（表述）只与你直接的朋友们通信；不要跟“陌生人”说话；每一个软件单位 对其他的单位都只有最少的了解，这些了解仅局限于那些与本单位密 切相关的软件单位。 对迪米特法则进行模式设计有两个：外观模式、中介者模式。 开闭原则：一个软件实体应当对扩展开放，对修改关闭。 重要性体现：提高复用性；提高维护性；提高灵活性；易于测试
uml中的关系 1、关联 双向关联： C1-C2：指双方都知道对方的存在，都可以调用对方的公共属性和方法。 在GOF的设计模式书上是这样描述的：虽然在分析阶段这种关系是适用的，但我们觉得它对于描述设计模式内的类关系来说显得太抽象了，因为在设计阶段关联关系必须被映射为对象引用或指针。对象引用本身就是有向的，更适合表达我们所讨论的那种关系。所以这种关系在设计的时候比较少用到，关联一般都是有向的。 使用ROSE 生成的代码是这样的： class C1 ...{ public: C2* theC2; }; class C2 ...{ public: C1* theC1; }; 双向关联在代码的表现为双方都拥有对方的一个指针，当然也可以是引用或者是值。 单向关联: C3->C4：表示相识关系，指C3知道C4，C3可以调用C4的公共属性和方法。没有生命期的依赖。一般是表示为一种引用。 生成代码如下：
class C3 ...{ public: C4* theC4; }; class C4 ...{ }; 单向关联的代码就表现为C3有C4的指针，而C4对C3一无所知。 自身关联（反身关联）： 自己引用自己，带着一个自己的引用。 代码如下： class C14 ...{ public: C14* theC14; }; 就是在自己的内部有着一个自身的引用。 2、聚合/组合 当类之间有整体-部分关系的时候，我们就可以使用组合或者聚合。
聚合：表示C9聚合C10，但是C10可以离开C9而独立存在（独立存在的意思是在某个应用的问题域中这个类的存在有意义。这句话怎么解，请看下面组合里的解释）。 代码如下： class C9 ...{ public: C10 theC10; }; class C10 ...{ }; 组合（也有人称为包容）：一般是实心菱形加实线箭头表示，如上图所示，表示的是C8被C7包容，而且C8不能离开C7而独立存在。但这是视问题域而定的，例如在关心汽车的领域里，轮胎是一定要组合在汽车类中的，因为它离开了汽车就没有意义了。但是在卖轮胎的店铺业务里，就算轮胎离开了汽车，它也是有意义的，这就可以用聚合了。在《敏捷开发》中还说到，A组合B，则A需要知道B的生存周期，即可能A负责生成或者释放B，或者A通过某种途径知道B 的生成和释放。 他们的代码如下： class C7 ...{ public: C8 theC8; }; class C8 ...{ }; 可以看到，代码和聚合是一样的。具体如何区别，可能就只能用语义来区分了。 3、依赖
关于23种设计模式新解 创建型模式 1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你” builder。（这一定比美军在伊拉克用的翻译机好卖） 建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的
细节。建造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的 MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。 工厂方法模式：核心工厂类不再负责所有产品的创建，而是将 具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给 出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例 化这种细节。 4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里 面就行了，这就是我的情话prototype了。（100块钱一份，你要 不要） 原始模型模式：通过给出一个原型对象来指明所要创建的对象 的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有 任何事先确定的等级结构，原始模型模式适用于任何的等级结构。 缺点是每一个类都必须配备一个克隆方法。 5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，
利用UML类图设计Java应用程序详解(一) UML已成为面向对象设计的标准图形化工具，在UML定义的各种图中，本文只涉及类图。Java应用程序由许多类所构成，类图的设计与实现，是Java实现面向对象应用程序的核心。本文通过一个具体的应用程序的设计与实现过程，详细说明了利用UML类图设计Java应用程序，使得开发过程标准化、可视化，代码编程简单化。 在类图中，类被描述为带有三层的盒子。 顶层为类名，一般用加粗字体表示。如果类是抽象的，其名称用斜体表示；如果类是接口，则在类名上方标注<
在该类中，有2个成员变量x和y,类图中，“-”表示变量或方法为private，“+”表示publ ic，“#”则表示protected。该类定义了三个不同的构造函数，这是重载（overload）的例子。接着该类设计了7个访问方法。getX()和getY()方法分别返回一点的x和y坐标。SetX()和setY()方法根据参数xValue和yValue的值设置这些坐标的值。两个add()方法通过被访问点的坐标加上一个值来建立一个新的Point对象。New运算符建立类的新实例。它后面紧跟着初始化新生成实例的构造函数。toString() 方法返回类String的一个对象，该对象用一个有序对来描述一个点。 依据设计的类图，其Java实现代码为：
Factory模式 1.简单工厂模式，又称静态工厂模式 2.工厂方法模式 3. 抽象工厂模式 抽象工厂模式与工厂方法模式的最大区别在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。
Singleton模式 要点： 类只能有一个实例 必须自行创建这个实例 必须自行向外界提供这个实例
Builder模式 Builder模式利用一个Director对象和ConcreteBuilder对象一个一个地建造出所有的零件，从而建造出完整的Product。Builder模式将产品的结构和产品的零件建造过程对客户端隐藏起来，把对建造过程进行指挥的责任和具体的建造者零件的责任分割开来，达到责任划分和封装的目的。 使用Builder模式的场合： 需要生成的产品对象有复杂的内部结构。每一个内部成分本身可以是对象，也可以紧紧是产品对象的一个组成部分。 需要生成的产品对象的属性相互以来。Builder模式可以强制实行一种分步骤进行的建造过程，因此，如果产品对象的一个属性必须在另一个属性被赋值之后才可以被赋值，使用建造模式便是一个很好的设计思想。 在对象创建过程中会使用到系统中的其他一些对象，这些对象在产品对象的创建过程中不易得到。
Prototype模式 通过给出一个原型对象来指明所要创建的对象的类型，然后用赋值这个原型对象的办法创建出更多同类型的对象。 Cloneable
Adapter模式 把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作，也就是说把接口不同而功能相同或相近的多个接口加以转换。 1.类的Adapter模式的结构 2.对象的Adapter模式的结构 注意两种结构的区别：主要就是Adaptee和Adapter的关系，一个为继承关系，一个为依
1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM 爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory。工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM 到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好