关于23种设计模式的有趣见解
23种设计模式趣味讲解
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了。
二十三种设计模式随笔记录
模式四个基本要素：1，模式名称；
2，问题；
3，解决方案；
4，效果。
SmallTalk MVC(三元组) ：包括类的模型/视图/控制器
（Model/View/Controller）
Model : 应用对象；
View : Model在屏幕上的显示；
Controller : 定义用户界面对用户输入的响应方式。
储存响应机制。
MVC特征：1，“订购/通知”协议来分离模型和视图；
2，视图可以嵌套；
MVC的主要关系是由Observer, Composite, Strategy 三个设计
模式给出的。
列举二十三种设计模式的主要意图：
Abstract Factory : 提供一个创建一系列相关或相互依赖对象的接
口，而无需指定它们具体的类；
Adapter : 将一个类的接口转换成客户希望的另外一个接口；使得原本由于接口不兼容而不能一起工作的那些类能一起工作；Bridge : 将抽象部分与它的实现部分分离，使他们可以独立地变化；
Builder : 将一个复杂对象的构建与它的表示分离，使同样的构建过
程可以创建不同的表示；
（待续）
设计模式分类准则：目的准则（创建，结构，行为）
范围准则（类，对象）
面向对象程序由对象组成，对象包括数据和对数据进行操作的方法。
对象收到客户的请求后，执行相应的操作；客户请求
是使对象操作的唯一方法，操作又是对象改变内部数
据的唯一方法。
面向对象设计最困难的部分是将系统分解成对象集合。
（因素：封装，粒子，依赖关系，灵活性，性能，演化，复用）。
23种设计模式简要说明
设计模式创建模式：1.factory：分为工厂方法和抽象工厂，将对象的创建和使用区分开，也就是说将创建对象时的一系列初始化工作从构造方法中剥离出来；它们唯一的区别在于在创建类的复杂程度上，抽象工厂指的是将共同部分封装在抽象类中，将不同部分延伸到其子类中去。
2.singleton：确保系统中只有一个实例对象的存在。
3.builder：若一个对象是由许多部件组成的，我们可以将部件的创建和组装过程区分开。
4.prototype：通过原型实例指定创建对象的类型，并且通过拷贝这些原型来创建新的对象。
结构模式：1.flyweight：避免大量拥有相同内容的小类的开销。
2.bridge：将抽象和行为划分开来，使得它们各自独立，但又能够动态的结合。
（继承抽象接口组合行为接口）。
3.decorator：动态的给一个对象添加一些额外的职责。
posite：将对象以树形结构的形式组合起来，已形成部分-到整体的层次结构，使客户端对单个对象和组合对象的使用具有一致性。
5.adapter：将原本两个没有关系的类结合在一起使用（有适配者和被适配者，您可以使用组合模式或者是继承模式）。
6.proxy：为其他对象提供一种代理以控制对这些对象的访问，典型的就是权限控制。
7.facade：为系统中的一组接口提供一个一致的界面。
（典型的就是数据库jdbc的操作）。
行为模式：1.Iterator：Iterator模式可以顺序的访问一个聚集中的元素而不必暴露该聚集的内部情况。
2.Template：定义操作中算法的骨架，将具体操作（一些步骤）的实现延迟到其子类中去。
3.chain of responsibility：通过一系列低耦合的类来试图处理一个request，唯一的共同点就是在它们之间传递request。
4.Memento：通过一个对象拷贝另外一个对象的内容状态，以将该对象恢复到原先保存的状态。
5.mediator：通过一个中介对象来封装一系列对象交互的行为，例如：Android中的Intent。
23种设计模式额形象比喻 (1)
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块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
面向对象设计的23个设计模式详解
面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
23种设计模式 详解
23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。
这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。
目前，常用的设计模式有23种。
下面，我们来详细介绍一下这23种设计模式。
1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。
在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。
2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。
它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。
3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。
它可以生成一系列相关或相互依赖的对象实例。
具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。
4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。
它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。
5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。
一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。
6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。
具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。
7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。
具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。
8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。
23种设计模式的形象比喻
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块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
23种设计模式及案例整理分享
23种设计模式及案例整理分享创建型模式⼯⼚模式⼯⼚模式（Factory Pattern）是 Java 中最常⽤的设计模式之⼀。
这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。
在⼯⼚模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。
介绍意图：定义⼀个创建对象的接⼝，让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类，⼯⼚模式使其创建过程延迟到⼦类进⾏。
主要解决：主要解决接⼝选择的问题。
何时使⽤：我们明确地计划不同条件下创建不同实例时。
如何解决：让其⼦类实现⼯⼚接⼝，返回的也是⼀个抽象的产品。
关键代码：创建过程在其⼦类执⾏。
应⽤实例： 1、您需要⼀辆汽车，可以直接从⼯⼚⾥⾯提货，⽽不⽤去管这辆汽车是怎么做出来的，以及这个汽车⾥⾯的具体实现。
2、Hibernate 换数据库只需换⽅⾔和驱动就可以。
优点： 1、⼀个调⽤者想创建⼀个对象，只要知道其名称就可以了。
2、扩展性⾼，如果想增加⼀个产品，只要扩展⼀个⼯⼚类就可以。
3、屏蔽产品的具体实现，调⽤者只关⼼产品的接⼝。
缺点：每次增加⼀个产品时，都需要增加⼀个具体类和对象实现⼯⼚，使得系统中类的个数成倍增加，在⼀定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
这并不是什么好事。
使⽤场景： 1、⽇志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，⽤户可以选择记录⽇志到什么地⽅。
2、数据库访问，当⽤户不知道最后系统采⽤哪⼀类数据库，以及数据库可能有变化时。
3、设计⼀个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现⼀个接⼝。
注意事项：作为⼀种创建类模式，在任何需要⽣成复杂对象的地⽅，都可以使⽤⼯⼚⽅法模式。
有⼀点需要注意的地⽅就是复杂对象适合使⽤⼯⼚模式，⽽简单对象，特别是只需要通过 new 就可以完成创建的对象，⽆需使⽤⼯⼚模式。
设计模式(23种设计模式巧妙解析,趣味理解)
追MM与设计模式（23种设计模式巧妙解析，趣味理解）2017-04-26程序员共读在网络上流畅很广的一篇旧文，暂时没找到原作者，目前所看到的最早转载时间是 2005 年 2 月 28 日。
作者用轻松的语言，形象解释了 23 种模式，有很好的启发作用。
创建型模式1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。
麦当劳和肯德基就是生产鸡翅的Factory工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。
（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
23种设计模式的经典运用
23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。
本文将介绍23种经典的设计模式，并给出它们在实际开发中的应用示例。
通过学习这些设计模式，您将增加对软件设计的理解，并能够更好地解决问题。
创建型设计模式1.工厂方法模式（F a c t o r y M e t h o d）工厂方法模式通过定义一个创建对象的接口，但由子类决定实例化具体类。
这种方法可以延迟实例化过程，具有更高的灵活性和可扩展性。
应用场景：-在一个系统中，希望客户端与具体类的实例化解耦。
-希望通过增加具体类的扩展来增加系统的灵活性。
2.抽象工厂模式（A b s t r a c t F a c t o r y）抽象工厂模式提供一个接口，用于创建相关或依赖对象组。
这种模式将对象的实例化推迟到子类中，从而实现了解耦。
应用场景：-当一个系统独立于其产品的创建、组合和表示时。
-当需要一个系列的相互依赖的对象而无需指定其具体类时。
3.单例模式（S i n gl e t o n）单例模式确保一个类只有一个实例，并提供一个全局访问点。
这种模式常用于控制对资源的访问，例如数据库连接或日志文件。
应用场景：-当需要一个类的唯一实例，并且该实例需要被多个客户端共享时。
-当需要限制系统中特定类的实例数量时。
4.原型模式（P r o to t y p e）原型模式通过复制现有对象来创建新对象。
这种模式对于创建需要消耗大量资源的对象非常有用，可以通过克隆现有对象来提高性能。
应用场景：-当一个系统的某些对象的创建比较昂贵时。
-当需要避免构造函数调用，而直接通过复制现有对象来创建新对象时。
5.建造者模式（B ui l d e r）建造者模式将一个复杂对象的构建过程与其表现分离，使得相同的构建过程可以创建不同的表现。
应用场景：-当想要构建一些复杂对象时，如生成器。
-当需要创建对象的过程具有多个步骤，并且每个步骤都可以按需选择或省略时。
结构型设计模式6.适配器模式（A da p t e r）适配器模式将一个类的接口转换为客户端所期望的另一个接口。
23种设计模式的理解,理解了才懂得什么情况下使用了什么样的设计模式
1.对设计模式了解少？项目中是否有运用到？对于23种设计模式都有学习过最少超过两三次吧，主要是学习到了一些设计思想，当通过对一些框架低层的了解，比如spring 中的AOP就用到了很多代理模式，通过代理一个对像，来对我们的方法进行控制，代理后，用到了装饰器模式（项目中操作记录日志，封装对像），装饰我们的目标对象，对我们的方法前后进后不同的操作，比如开启事务，日志处理、提交、回滚、结果返回等操作。
（1）比如java的io体系，可以一层包装一层，外面的一层，都会对里面的一层进行功能的增强。
（2）还有就是spring的aop，aop这块可以基于动态代理的理念，装饰我们的目标对象，然后加入事务控制，日志打印之类的功能。
当然这一串的操作不可能在一个方法中处理，就用到了责任连模式，通过链式调用，按不同的顺执行。
在我们项目中，比如导出功能，用到了模板设计模式，以及价格计算用到了策略模式加工厂模式，计算以责任连模式进行对不同价格的计算或项目中对8种税的计算流程，根据不同的类型计算得到不同的对像，执行不同的计算逻辑，也用到了模板设计模式加工厂模式，不管你算什么价，最终这个价都不能低于地板价都需要对地板价进行校验，这样，地板价校验都是公共的抽成模板处理方式，每个特殊的算价走对应的抽像方法执行算价。
项目中的采购入库及退货入库，都会进行库存数据的修改，一些公用的比如对商品的更新、数量加减这一顺序基本一样，可以抽成模板设计、然后不同的逻辑对应的类去执行这就是命令模式，在把这些逻辑封装在一个工厂里面，就成了工厂模式。
策略模式跟命令模式的区别？看起来一样的，但是用处不一样。
命令是可以发送出去，然后可以经过一些队列的流转，比如先把命令发送到MQ，接着再处理。
策略是说选择了一组策略，立即就要执行的，不会经过其他别的什么处理。
而且策略逻辑基本就是用在复杂的if else代码中的命令模式，可以用在更多别的场景中思想是不一样的，也许实现上，接口、实现类、工厂来做的，适合的场景是不一样的状态模式状态模式里，非常重要的一点就是将状态之间流转的逻辑，封装在Context类里面。
论23种设计模式的形象比喻(doc 10页)
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块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
23种设计模式范文
23种设计模式范文设计模式是用来解决软件设计中的常见问题的经验总结和最佳实践。
这些模式抽象了实际应用中的问题，并提供了相应的解决方案。
本文将介绍23种经典的设计模式，并简要描述它们的用途和示例。
1.创建型模式-单例模式：保证一个类只有一个实例，并提供一个全局访问点。
-工厂模式：将对象的创建委托给工厂类，隐藏具体实现细节。
-抽象工厂模式：提供一个用于创建一系列相关或相互依赖对象的接口。
-建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
-原型模式：通过复制已有对象来创建新对象，避免了直接创建对象的开销。
2.结构型模式-适配器模式：将一个类的接口转换成客户希望的另一个接口。
-桥接模式：将抽象部分与其实现部分相分离，使它们可以独立变化。
-组合模式：将对象组合成树形结构以表示"部分-整体"的层次结构。
-装饰者模式：动态地给对象添加额外的职责，同时又不改变其结构。
-外观模式：为复杂子系统提供一个简化的接口。
-享元模式：通过共享对象来实现对大量细粒度对象的有效共享。
3.行为型模式-模板方法模式：定义一个操作中的算法框架，将一些步骤的具体实现延迟到子类中。
-命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化。
-迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。
-观察者模式：定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。
-中介者模式：用一个中介对象封装一系列对象的交互，使各对象不需要显示地相互引用。
-备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
-解释器模式：给定一个语言，定义它的语法的一种表示，并定义一个解释器来解释该语言中的句子。
-状态模式：允许对象在其内部状态改变时改变它的行为。
-空对象模式：使用一个空对象来代替NULL对象的检查。
浅析23种软件设计模式
浅析23种软件设计模式软件设计模式是解决特定问题的一种经过验证的解决方案。
它们是开发者在软件设计过程中基于经验总结出来的最佳实践。
《设计模式》一书中总结了23种常见的软件设计模式，本文将对这23种模式进行浅析。
一、创建型模式1. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
常用于线程池、数据库连接等需要全局唯一实例的场景。
2. 工厂模式（Factory Pattern）：通过工厂类创建对象，将对象的创建与使用分离，提供了一种统一的接口来创建各种不同类型的对象。
3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
4. 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）：通过克隆对象来创建新的对象，避免了通过new关键字创建对象的开销。
二、结构型模式6. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端所期望的另一个接口，使得原本因接口不兼容而不能在一起工作的类可以一起工作。
7. 桥接模式（Bridge Pattern）：将抽象与实现分离，使它们可以独立变化。
通过组合的方式来实现类之间的关系。
9. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，同时不改变其原有的结构。
10. 外观模式（Facade Pattern）：为一组复杂的子系统提供一个更高级别的接口，简化对子系统的访问。
11. 享元模式（Flyweight Pattern）：运用共享技术来有效支持大量细粒度对象的复用。
12. 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。
三、行为型模式13. 模板方法模式（Template Method Pattern）：定义一个操作中的算法框架，将一些步骤延迟到子类中实现。
关于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块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
23种设计模式的意图及实用性
一．创建型模式1．单件模式意图保证一个类仅有一个实例，并提供一个访问它的全局访问点。
适用性当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
2．抽象工厂意图提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时。
当你提供一个产品类库，而只想显示它们的接口而不是实现时。
3．建造者模式意图将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
适用性当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
当构造过程必须允许被构造的对象有不同的表示时。
4．工厂方法模式意图定义一个用于创建对象的接口，让子类决定实例化哪一个类。
Factory Method 使一个类的实例化延迟到其子类。
适用性当一个类不知道它所必须创建的对象的类的时候。
当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
5．原型模式意图用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用性当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者为了避免创建一个与产品类层次平行的工厂类层次时；或者当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
二．结构型模式6．适配器模式意图将一个类的接口转换成客户希望的另外一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
适用性你想使用一个已经存在的类，而它的接口不符合你的需求。
你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
详解23种设计模式
详解23种设计模式设计模式（Design Patterns） ⾸先说⼀下我对设计模式的理解，设计模式是⼀种在软件内部优化代码的技巧。
注意，是代码的内部，也就是在⼀个局部范围内优化设计。
这⼀点和软件的架构是完全不同的，软件架构是全局的优化，讲的是怎么对软件进⾏切分以及对切开之后的内容进⾏重组的⼀个过程。
软件的设计模式强调的是代码，软件架构强调的是结构。
在⾯向对象的编程思想中，这就体现在怎么解决类与类之间的关系。
能处理好类与类之间的关系，优化设计就搞好了。
下⾯这段话是软件设计模式的定义： 设计模式（Design pattern）是⼀套被反复使⽤、多数⼈知晓的、经过分类编⽬的、代码设计经验的总结。
使⽤设计模式是为了可重⽤代码、让代码更容易被他⼈理解、保证代码可靠性。
毫⽆疑问，设计模式于⼰于他⼈于系统都是多赢的，设计模式使代码编制真正⼯程化，设计模式是软件⼯程的基⽯，如同⼤厦的⼀块块砖⽯⼀样。
项⽬中合理的运⽤设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每⼀个模式描述了⼀个在我们周围不断重复发⽣的问题，以及该问题的核⼼解决⽅案，这也是它能被⼴泛应⽤的原因。
设计模式是⼀代⼜⼀代的编程⼤师总结出来的，我们应该重视，不能束之⾼阁，应当合理利⽤。
关键是要搞清楚哪种情况⽤哪种设计模式。
⼀、设计模式的分类总体来说设计模式分为三⼤类：创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。
（还有⼀种叫简单⼯⼚模式，是⼯⼚模式的变形，不满⾜单⼀职责，设计不太合理，所以就没列出来）结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
⼆、设计模式的七⼤原则设计模式的七⼤原则堪称经典，这七条原则是我们在设计软件的过程中必须准守的，当然不遵守的话，你的⽼板可能就会“嘿嘿”你，你懂得！这七条原则指导了23种设计模式，可以这么说，23种设计模式就是在这七条原则在不同场景之下的应⽤。
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块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
设计模式23个模式和意图
设计模式23个模式和意图：（1）抽象工厂（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
（2）适配器（Adapter）：将一个类的接口转换成客户希望的另外一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的哪些类可以一起工作。
（3）桥接（Bridge）：将抽象部分与它的实现部分分离，是他们都可以独立的变化。
（4）生成器（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
（5）职责连（Chain of responsibility）：为解除请求的发送者和接收者之间的耦合，而使多个对象都有机会处理这个请求。
将这些对象连成一条连，并沿着这条连传递该请求，直到有一个对象处理它。
（6）命令（Command)：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。
（7）组成(Composite)：将对象组合成树形结构以表示“部分—整体”的层次结构。
Composite使得客户对单个对象和复合对象的使用具有一致性。
（8）装饰(Decorator)：动态的给一个对象添加一些额外的职责。
就扩展功能而言，Decorator模式比生成子类模式更为灵活。
（9）外观(Facade)：为子系统中的一类接口提供一个一致的界面，Fa?ade模式定义了一个高层接口，这个接口使得这一子系统更为灵活。
（10）工厂方法(Factory method)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
Factory method使得一个类的实例化延迟到其子类。
（11）享元(Flyweight)：运用共享技术有效的支持大量细粒度的对象。
（12）解释器(Interperter)：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
作者以轻松的语言比喻了Java的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，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事)单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
结构型模式6、ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。
不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、COMPOSITE—Mary今天过生日。
“我过生日，你要送我一件礼物。
”“嗯，好吧，去商店，你自己挑。
”“这件T恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。
”“喂，买了三件了呀，我只答应送一件礼物的哦。
”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。
” “……”，MM都会用Composite模式了，你会了没有？合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
合成模式就是一个处理对象的树结构的模式。
合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。
动态给一个对象增加功能，这些功能可以再动态的撤消。
增加由一些基本功能的排列组合而产生的非常大量的功能。
10、FACADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也不会。
幸好相机有Facade设计模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，这样MM 也可以用这个相机给我拍张照片了。
门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。
门面模式提供一个高层次的接口，使得子系统更易于使用。
每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。
但整个系统可以有多个门面类。
11、FLYWEIGHT—每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里，要用的时候，直接拿出来，在前面加上MM的名字就可以发送了，再不用一个字一个字敲了。
共享的句子就是Flyweight，MM的名字就是提取出来的外部特征，根据上下文情况使用。
享元模式：FLYWEIGHT在拳击比赛中指最轻量级。
享元模式以共享的方式高效的支持大量的细粒度对象。
享元模式能做到共享的关键是区分内蕴状态和外蕴状态。
内蕴状态存储在享元内部，不会随环境的改变而有所不同。
外蕴状态是随环境的改变而改变的。
外蕴状态不能影响内蕴状态，它们是相互独立的。
将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。
客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。
享元模式大幅度的降低内存中对象的数量。
12、PROXY—跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀？”“你多大了？”“身高多少呀？”这些话，真烦人，写个程序做为我的Proxy吧，凡是接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，酷吧。
代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。
代理就是一个人或一个机构代表另一个人或者一个机构采取行动。
某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。
客户端分辨不出代理主题对象与真实主题对象。
代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。
行为模式13、CHAIN OF RESPONSIBLEITY—晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的MM哎，找张纸条，写上“Hi,可以做我的女朋友吗？如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸条传给老师了，听说是个老处女呀，快跑!责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。
请求在这个链上传递，直到链上的某一个对象决定处理此请求。
客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。
处理者有两个选择：承担责任或者把责任推给下家。
一个请求可以最终不被任何接收端对象所接受。
14、COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给我。
这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“我同时给我姐姐三个男朋友送COMMAND，就数你最小气，才请我吃面。
”，:-(命令模式：命令模式把一个请求或者操作封装到一个对象中。
命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。
系统支持命令的撤消。
15、INTERPRETER—俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃西餐的步骤、去看电影的方法等等，跟MM约会时，只要做一个Interpreter，照着上面的脚本执行就可以了。
解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。
客户端可以使用这个解释器来解释这个语言中的句子。
解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。
在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。
在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。
每一个命令对象都有一个解释方法，代表对命令对象的解释。
命令对象的等级结构中的对象的任何排列组合都是一个语言。
16、ITERATOR—我爱上了Mary，不顾一切的向她求婚。
Mary：“想要我跟你结婚，得答应我的条件”我：“什么条件我都答应，你说吧”Mary：“我看上了那个一克拉的钻石”我：“我买，我买，还有吗？”Mary：“我看上了湖边的那栋别墅”我：“我买，我买，还有吗？”Mary：“你的小弟弟必须要有50cm长”我脑袋嗡的一声，坐在椅子上，一咬牙：“我剪，我剪，还有吗？”……迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。
多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。
迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。
迭代子模式简化了聚集的界面。
每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。
迭代算法可以独立于聚集角色变化。
17、MEDIATOR—四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时我在旁边，按照各自的筹码数算钱，赚了钱的从我这里拿，赔了钱的也付给我，一切就OK啦，俺得到了四个MM的电话。