23种设计模式的通俗理解
23种设计模式
设计模式的分类1.抽象工厂Abstract FACTORY厂模式：客户类和工厂类分开，把各种需要使用到的实例的创建方法统一单独写成抽象类，实现类具体实现创建过程，创建出来的对象类型用接口来表示，抽象工厂可以用在高层类中使用，不用考虑太多具体的创建细节，如何创建由工厂的具体实现去定义。
核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
2.BUILDER建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3.FACTORY METHOD工厂方法模式：用一个方法来创建所需要的所有实例，跟抽象工厂的区别，就是不需要单独写个工厂类，相当于把抽象工厂类里面定义的抽象方法，合并到应用类里面，子类去实现就好了，比抽象工厂更简洁。
4. PROTOTYPE原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5.SINGLETON单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
6.ADAPTER适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7.BRIDGE桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
23种设计模式及应用
23种设计模式及应用设计模式是指在软件设计过程中，针对常见问题的解决方案的经验总结。
它们提供了解决特定或常见问题的可重用方案，使得软件设计更加灵活、可扩展和可维护。
1. 创建型模式：- 单例模式：确保一个类只有一个实例，并提供全局访问点。
- 简单工厂模式：通过一个共同的接口创建不同的对象实例。
- 工厂方法模式：定义一个创建对象的接口，由子类决定具体创建哪个对象。
- 抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口。
- 建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
2. 结构型模式：- 适配器模式：将一个类的接口转换为客户端所期待的另一种接口。
- 桥接模式：将抽象部分与它的实现部分分离，使它们可以独立变化。
- 组合模式：将对象组合成树形结构以表示"整体-部分"的层次结构。
- 装饰器模式：动态地给对象添加额外的功能，避免继承带来的类膨胀问题。
- 外观模式：为子系统中一组接口提供一个一致的界面。
3. 行为型模式：- 策略模式：定义一系列算法，将它们封装起来，并使它们可以相互替换。
- 观察者模式：定义对象之间的依赖关系，当对象状态改变时自动通知依赖方。
- 模板方法模式：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。
- 命令模式：将一个请求封装成一个对象，从而使您可以用不同的请求参数化客户端对象。
- 状态模式：允许对象在其内部状态改变时改变其行为。
4. J2EE模式：- MVC模式：将应用程序划分为三个核心组件：模型、视图和控制器。
- 业务代表模式：将对业务对象的访问和业务逻辑从表示层分离出来。
- 数据访问对象模式：用于将业务逻辑和数据访问逻辑分离。
- 前端控制器模式：通过一个单一的入口点来处理应用程序的所有请求。
- 传输对象模式：用于在客户端和服务器之间传输数据。
5. 并发模式：- 线程池模式：创建一组预先初始化的线程对象来处理任务。
面向对象23种设计模式
面向对象23种设计模式面向对象23种设计模式在面向对象的编程中，设计模式是一种解决问题的通用方案。
设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并提高代码的可维护性和可重用性。
本文将介绍23种面向对象的设计模式。
1. 工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。
在工厂方法模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
2. 抽象工厂模式抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
在抽象工厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
3. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局点。
4. 原型模式原型模式是一种创建型设计模式，它允许复制或克隆一个现有的对象，而不必知道其具体实现。
5. 建造者模式建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。
6. 适配器模式适配器模式是一种结构型设计模式，它将一个或多个不兼容的类或接口转换为客户端所需的接口。
7. 桥接模式桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。
8. 组合模式组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。
9. 装饰器模式装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。
10. 外观模式外观模式是一种结构型设计模式，它为一组复杂的子系统提供了一个统一的接口，以便于客户端使用。
11. 享元模式享元模式是一种结构型设计模式，它利用共享技术来最小化内存使用，以及提高应用程序的性能。
12. 代理模式代理模式是一种结构型设计模式，它提供了一个代理对象，使得客户端可以通过代理对象间接地访问实际对象。
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种设计模式简单实例
23种设计模式简单实例设计模式是解决软件设计中常见问题的经典解决方案，它们被广泛应用于软件工程中。
本文将介绍23种设计模式，并提供每种模式的简单实例来帮助读者更好地理解和应用这些模式。
1. 创建型模式（Creational Patterns）1.1 简单工厂模式（Simple Factory Pattern）：一个工厂类根据传入的参数决定创建哪一种产品类的实例。
例如，一个汽车工厂根据参数创建不同型号的汽车。
1.2 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。
例如，一个汽车品牌父类提供创建具体汽车型号的方法，由子类决定具体型号。
1.3 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
例如，一个汽车制造工厂提供创建汽车引擎和轮胎的方法。
1.4 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
例如，一个套餐包括饮料、主食和甜品等多个组件，可以通过建造者模式逐步构建套餐。
1.5 单例模式（Singleton Pattern）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
例如，一个日志管理器只能有一个实例，可以通过单例模式实现。
2. 结构型模式（Structural Patterns）2.1 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。
例如，将一个新的USB设备适配到旧的电脑接口上。
2.2 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。
例如，一个画图软件可以通过装饰器模式给图形对象添加边框或阴影等功能。
2.3 代理模式（Proxy Pattern）：为其他对象提供一个代理以控制对这个对象的访问。
二十三种设计模式的通俗理解
二十三种设计模式的通俗理解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个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
23种设计模式 简单明了
23种设计模式简单明了1. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
2. 工厂模式（Factory Pattern）：定义创建对象的接口，但将实际创建对象的过程推迟到子类中。
3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关对象的接口，而无需指定具体的类。
4. 建造者模式（Builder Pattern）：将一个复杂对象的创建与表示分离，使同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）：通过复制现有的对象来创建新对象。
6. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。
7. 桥接模式（Bridge Pattern）：将抽象与实现分离，使它们可以独立变化，从而减少两者之间的耦合。
8. 过滤器模式（Filter Pattern）：通过某种条件来过滤一组对象。
9. 组合模式（Composite Pattern）：将对象组合成树形结构，以表示 "部分-整体" 的层次结构。
10. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。
11. 外观模式（Facade Pattern）：隐藏系统的复杂性，并向客户端提供一个简化的接口。
12. 享元模式（Flyweight Pattern）：共享对象，以便有效地支持大量细粒度的对象。
13. 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。
14. 责任链模式（Chain of Responsibility Pattern）：将请求的发送者和接收者解耦，并让多个对象都有机会处理这个请求。
15. 命令模式（Command Pattern）：将请求封装成对象，从而允许使用不同的请求、队列或者日志请求。
16. 解释器模式（Interpreter Pattern）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
23种设计模式 详解
23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。
这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。
目前，常用的设计模式有23种。
下面，我们来详细介绍一下这23种设计模式。
1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。
在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。
2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。
它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。
3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。
它可以生成一系列相关或相互依赖的对象实例。
具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。
4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。
它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。
5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。
一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。
6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。
具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。
7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。
具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。
8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。
常见的23种设计模式
常见的23种设计模式⼀般模式有4个基本要素：模式名称（pattern name）、问题（problem）、解决⽅案（solution）、效果（consequences）。
按照设计模式的⽬的可以分为三⼤类：创建型、结构型、⾏为型。
⼀、创建型设计模式1、抽象⼯⼚（Abstract Factory）：提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆需指定它们具体的类。
2、⽣成器（Builder）：将⼀个复杂对象的构建与它的表⽰分离，使他们都可以独⽴地变化。
3、⼯⼚⽅法（Factory Method）：定义⼀个⽤于创建对象的接⼝，让⼦类决定实例化哪⼀个类。
Factory Method使⼀个类的实例化延迟到其⼦类。
4、原型（Prototype）：⽤原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
5、单例（Singleton）：保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点。
⼆、结构型设计模式1、适配器（Adapter）：将⼀个类的接⼝转换成客户希望的另⼀个接⼝。
Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。
2、桥接（Bridge）：将抽象部分与其实现部分分离，使它们都可以独⽴地变化。
3、组合（Composite）：将对象组合成树型结构以表⽰“部分-整体”的层次结构。
Composite使得⽤户对单个对象和组合对象的使⽤具有⼀致性。
4、装饰（Decorator）：动态地给⼀个对象添加⼀些额外的职责。
就增加功能⽽⾔，Decorator模式⽐⽣成⼦类更加灵活。
5、外观（Facade）：为⼦系统中的⼀组接⼝提供⼀个⼀致的界⾯，Facade模式定义了⼀个⾼层接⼝，这个接⼝使得这⼀⼦系统更加容易使⽤。
6、享元（Flyweight）：运⽤共享技术有效地⽀持⼤量细粒度的对象。
7、代理（Proxy）：为其他对象提供⼀种代理以控制对这个对象的访问。
三、⾏为设计模式1、责任链（Chain of Responsibility）：使多个对象都有机会处理请求，从⽽避免请求的发送者和接收者之间的耦合关系。
23种设计模式
23种设计模式设计模式主要分为三⼤类：创建型、结构型、⾏为型创建型创建型模式简单来说就是⽤来创建对象的。
⼀共有五种：单例模式、建造者模式、⼯⼚⽅法模式、抽象⼯⼚模式、原型模式。
单例模式：确保某⼀个类只有⼀个实例，并且提供⼀个全局访问点。
建造者模式：⽤来创建复杂的复合对象。
⼯⼚⽅法模式：让⼦类来决定要创建哪个对象。
抽象⼯⼚模式：创建多个产品族中的产品对象。
原型模式：通过复制原型来创建新对象。
结构型结构型模式主要是⽤于处理类或者对象的组合。
⼀共有七种：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式代理模式：控制客户端对对象的访问。
组合模式：将整体与局部（树形结构）进⾏递归组合，让客户端能够以⼀种的⽅式对其进⾏处理。
适配器模式：将原来不兼容的两个类融合在⼀起。
装饰者模式：为对象添加新功能。
享元模式：使⽤对象池来减少重复对象的创建。
外观模式：对外提供⼀个统⼀的接⼝⽤来访问⼦系统。
桥接模式：将两个能够独⽴变化的部分分离开来。
⾏为型⾏为型模式主要是描述类或者对象是怎样交互和怎样分配职责的。
⼀共有⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式策略模式：封装不同的算法，算法之间能互相替换。
状态模式：根据不同的状态做出不同的⾏为。
责任连模式：将事件沿着链去处理。
观察者模式：状态发⽣改变时通知观察者，⼀对多的关系。
模板⽅法模式：定义⼀套流程模板，根据需要实现模板中的操作。
迭代器模式：提供⼀种⽅法顺序访问⼀个聚合对象中的各个元素。
迭代器模式：保存对象的状态，在需要时进⾏恢复。
访问者模式：稳定数据结构中，定义新的操作⾏为。
中介者模式：将⽹状结构转变为星型结构，所有⾏为都通过中介。
解释器模式：定义语法，并对其进⾏解释。
命令模式：将请求封装成命令，并记录下来，能够撤销与重做。
23种设计模式的理解,理解了才懂得什么情况下使用了什么样的设计模式
1.对设计模式了解少？项目中是否有运用到？对于23种设计模式都有学习过最少超过两三次吧，主要是学习到了一些设计思想，当通过对一些框架低层的了解，比如spring 中的AOP就用到了很多代理模式，通过代理一个对像，来对我们的方法进行控制，代理后，用到了装饰器模式（项目中操作记录日志，封装对像），装饰我们的目标对象，对我们的方法前后进后不同的操作，比如开启事务，日志处理、提交、回滚、结果返回等操作。
（1）比如java的io体系，可以一层包装一层，外面的一层，都会对里面的一层进行功能的增强。
（2）还有就是spring的aop，aop这块可以基于动态代理的理念，装饰我们的目标对象，然后加入事务控制，日志打印之类的功能。
当然这一串的操作不可能在一个方法中处理，就用到了责任连模式，通过链式调用，按不同的顺执行。
在我们项目中，比如导出功能，用到了模板设计模式，以及价格计算用到了策略模式加工厂模式，计算以责任连模式进行对不同价格的计算或项目中对8种税的计算流程，根据不同的类型计算得到不同的对像，执行不同的计算逻辑，也用到了模板设计模式加工厂模式，不管你算什么价，最终这个价都不能低于地板价都需要对地板价进行校验，这样，地板价校验都是公共的抽成模板处理方式，每个特殊的算价走对应的抽像方法执行算价。
项目中的采购入库及退货入库，都会进行库存数据的修改，一些公用的比如对商品的更新、数量加减这一顺序基本一样，可以抽成模板设计、然后不同的逻辑对应的类去执行这就是命令模式，在把这些逻辑封装在一个工厂里面，就成了工厂模式。
策略模式跟命令模式的区别？看起来一样的，但是用处不一样。
命令是可以发送出去，然后可以经过一些队列的流转，比如先把命令发送到MQ，接着再处理。
策略是说选择了一组策略，立即就要执行的，不会经过其他别的什么处理。
而且策略逻辑基本就是用在复杂的if else代码中的命令模式，可以用在更多别的场景中思想是不一样的，也许实现上，接口、实现类、工厂来做的，适合的场景是不一样的状态模式状态模式里，非常重要的一点就是将状态之间流转的逻辑，封装在Context类里面。
设计模式-23种设计模式整体介绍及应用场景、七大设计原则总结
设计模式-23种设计模式整体介绍及应⽤场景、七⼤设计原则总结对象的⼀、创建型模式：都是⽤来帮助我们创建对象的!（关注（关注对象的创建过程））创建过程模式1.单例单例模式保证⼀个类只有⼀个实例，并且提供⼀个访问该实例的全局访问点。
模式("Gof book"中把⼯⼚⽅法与抽象⼯⼚分为两种模式，所以创建型模式共为⼯⼚模式2.⼯⼚五种，这⾥只是为了⽅便整理，合在了⼯⼚模式中)-简单⼯⼚模式⽤来⽣产同⼀等级结构的任意产品。
（对于增加新的产品，需要修改已有代码）-⼯⼚⽅法模式⽤来⽣成同⼀等级结构中的固定产品。
（⽀持增加任意产品）-抽象⼯⼚模式⽤来⽣产不同产品族的全部产品。
（对于增加新的产品，⽆能为⼒，⽀持增加产品族）模式3.建造者建造者模式分离了对象⼦组件的单独构造（由Builder来负责）和装配（由Director负责），从⽽可以构造出复杂的对象。
模式原型模式4.原型通过new产⽣⼀个对象需要⾮常繁琐的数据准备或访问权限，则可以使⽤原型模式。
耦合，从⽽可以松耦合，从⽽可以扩⼤扩⼤结构上实现上实现松⼆、结构型模式：是从程序的、结构型模式：是从程序的结构对象和和类的组织）类的组织）（关注对象解决更⼤的问题。
（关注整体的类结构，⽤来整体的类结构，⽤来解决更⼤的问题。
模式1.适配器适配器模式⼯作中的场景：经常⽤来做旧系统改造和升级；如果我们的系统开发之后再也不需要维护，那么很多模式都是没必要的，但是不幸的是，事实却是维护⼀个系统的代价往往是开发⼀个系统的数倍。
学习中见过的场景：java.io.InputStreamReader(InputStream); java.io.OutpuStreamWriter(OutputStream)模式2.代理代理模式核⼼作⽤：通过代理，控制对对象的访问！可以详细控制访问某个（某类）对象的⽅法，在调⽤这个⽅法前做前置处理，调⽤这个⽅法后做后置处理。
（即：AOP的微观实现！）AOP（Aspect Oriented Programming⾯向切⾯编程）的核⼼实现机制！开发框架中应⽤场景：structs2中拦截器的实现；数据库连接池关闭处理；Hibernate中延时加载的实现；mybatis中实现拦截器插件；AspectJ的实现；spring中AOP的实现（⽇志拦截，声明式事务处理）；web service；RMI远程⽅法调⽤模式桥接模式3.桥接实际开发中应⽤场景：JDBC驱动程序；AWT中的Peer架构；银⾏⽇志管理：格式分类：操作⽇志、交易⽇志、异常⽇志距离分类：本地记录⽇志、异地记录⽇志⼈⼒资源系统中的奖⾦计算模块：奖⾦分类：个⼈奖⾦、团体奖⾦、激励奖⾦。
23中设计模式的基本介绍
23中设计模式的基本介绍展开全文创建型模式(Creational Pattern)1、抽象工厂模式(Abstract Factory Pattern)介绍提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2、建造者模式(Builder Pattern)介绍将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
3、原型模式(Prototype Pattern)介绍用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
4、工厂方法模式(Factory Method Pattern)介绍定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
Factory Method使一个类的实例化延迟到其子类。
5、单例模式(Singleton Pattern)介绍保证一个类仅有一个实例，并提供一个访问它的全局访问点。
结构型模式(Structural Pattern)6、适配器模式(Adapter Pattern)介绍将一个类的接口转换成客户希望的另外一个接口。
Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
7、桥接模式(Bridge Pattern)介绍将抽象部分与它的实现部分分离，使它们都可以独立地变化。
8、组合模式(Composite Pattern)介绍将对象组合成树形结构以表示“部分-整体”的层次结构。
它使得客户对单个对象和复合对象的使用具有一致性。
9、装饰模式(Decorator Pattern)介绍动态地给一个对象添加一些额外的职责。
就扩展功能而言，它比生成子类方式更为灵活。
10、外观模式(Facade Pattern)介绍为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
11、享元模式(Flyweight Pattern)介绍运用共享技术有效地支持大量细粒度的对象。
软件设计常见的23种设计模式
软件设计常见的23种设计模式 在现代软件开发当中，设计模式起到⾄关重要的作⽤。
尤其是⾃从⾯向对象的语⾔普遍使⽤以后，促成了团队合作设计的热潮，⽽在此时，没有⼀个好的设计模式，软件设计⼏乎成了不可能完成的任务。
⼀般模式有4个基本要素：模式名称（pattern name）、问题（problem）、解决⽅案（solution）、效果（consequences）。
常见23种模式概述： 1）抽象⼯⼚模式（Abstract Factory）：提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆需指定它们具体的类。
2）适配器模式（Adapter）：将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。
适配器模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的类可以⼀起⼯作。
3）桥梁模式（Bridge）：将抽象部分与它的实现部分分离，使它们都可以独⽴地变化。
4）建造模式（Builder）：将⼀个复杂对象的构建与它的表⽰分离，使同样的构建过程可以创建不同的表⽰。
5）责任链模式（Chain of Responsibility）：为解除请求的发送者和接收者之间耦合，⽽使多个对象都有机会处理这个请求。
将这些对象连成⼀条链，并沿着这条链传递该请求，直到有⼀个对象处理它。
6）命令模式（Command）：将⼀个请求封装为⼀个对象，从⽽可⽤不同的请求对客户进⾏参数化；对请求排队或记录请求⽇志，以及⽀持可取消的操作。
7）合成模式（Composite）：将对象组合成树形结构以表⽰“部分－整体”的层次结构。
它使得客户对单个对象和复合对象的使⽤具有⼀致性。
8）装饰模式（Decorator）：动态地给⼀个对象添加⼀些额外的职责。
就扩展功能⽽⾔，它能⽣成⼦类的⽅式更为灵活。
9）门⾯模式（Facade）：为⼦系统中的⼀组接⼝提供⼀个⼀致的界⾯，门⾯模式定义了⼀个⾼层接⼝，这个接⼝使得这⼀⼦系统更加容易使⽤。
10）⼯⼚⽅法（Factory Method）：定义⼀个⽤于创建对象的接⼝，让⼦类决定将哪⼀个类实例化。
软件设计常见的23种设计模式
软件设计常见的23种设计模式 在现代软件开发当中，设计模式起到⾄关重要的作⽤。
尤其是⾃从⾯向对象的语⾔普遍使⽤以后，促成了团队合作设计的热潮，⽽在此时，没有⼀个好的设计模式，软件设计⼏乎成了不可能完成的任务。
⼀般模式有4个基本要素：模式名称（pattern name）、问题（problem）、解决⽅案（solution）、效果（consequences）。
常见23种模式概述： 1）抽象⼯⼚模式（Abstract Factory）：提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆需指定它们具体的类。
2）适配器模式（Adapter）：将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。
适配器模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的类可以⼀起⼯作。
3）桥梁模式（Bridge）：将抽象部分与它的实现部分分离，使它们都可以独⽴地变化。
4）建造模式（Builder）：将⼀个复杂对象的构建与它的表⽰分离，使同样的构建过程可以创建不同的表⽰。
5）责任链模式（Chain of Responsibility）：为解除请求的发送者和接收者之间耦合，⽽使多个对象都有机会处理这个请求。
将这些对象连成⼀条链，并沿着这条链传递该请求，直到有⼀个对象处理它。
6）命令模式（Command）：将⼀个请求封装为⼀个对象，从⽽可⽤不同的请求对客户进⾏参数化；对请求排队或记录请求⽇志，以及⽀持可取消的操作。
7）合成模式（Composite）：将对象组合成树形结构以表⽰“部分－整体”的层次结构。
它使得客户对单个对象和复合对象的使⽤具有⼀致性。
8）装饰模式（Decorator）：动态地给⼀个对象添加⼀些额外的职责。
就扩展功能⽽⾔，它能⽣成⼦类的⽅式更为灵活。
9）门⾯模式（Facade）：为⼦系统中的⼀组接⼝提供⼀个⼀致的界⾯，门⾯模式定义了⼀个⾼层接⼝，这个接⼝使得这⼀⼦系统更加容易使⽤。
10）⼯⼚⽅法（Factory Method）：定义⼀个⽤于创建对象的接⼝，让⼦类决定将哪⼀个类实例化。
23种编程设计模式
23种编程设计模式编程设计模式是在软件开发过程中经过实践验证的解决问题的方案，它们是解决常见问题的模板。
在设计模式的指导下，开发人员可以更加高效地开发出可维护、可扩展的软件。
本文将介绍23种常见的编程设计模式。
1.创建型模式：-工厂方法模式：当需要创建复杂对象时，通过工厂方法来解决对象的创建问题，将具体对象的创建延迟到子类中。
-抽象工厂模式：提供一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定具体类。
-单例模式：确保类只有一个实例，并提供一个全局访问点。
-原型模式：通过复制现有对象的方式，创建新的对象。
2.结构型模式：-适配器模式：将一个类的接口转换成客户期望的另一个接口，使得原本因接口不兼容而无法工作的类可以一起工作。
-桥接模式：将抽象部分与它们的实现部分分离，以便二者可以独立地变化。
-组合模式：将对象组合成树形结构以表示“整体-部分”层次结构。
-装饰器模式：动态地给对象添加一些额外的职责，而不需要修改其原始类的代码。
-外观模式：提供一个统一的接口，用于访问子系统中一群接口的功能。
-享元模式：通过共享对象来减少内存使用量。
-代理模式：为其他对象提供一个代理，以控制对这个对象的访问。
3.行为型模式：-责任链模式：将请求的发送者和接收者解耦。
-命令模式：将请求封装成一个对象，从而允许参数化对客户端不同的请求、排队或记录请求日志，以及支持可撤消的操作。
-解释器模式：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子。
-迭代器模式：提供一种顺序访问聚合对象中各个元素的方法，而又不暴露聚合对象的内部表示。
-中介者模式：用一个中介对象来封装一系列的对象交互。
-备忘录模式：在不违背封装原则的前提下，保存对象内部状态的快照，以便在将来需要时恢复到该状态。
-观察者模式：定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生变化时，所有依赖它的对象都得到通知。
-状态模式：允许对象在其内部状态改变时改变它的行为。
Java的23种设计模式
1、工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
6、适配器(变压器)模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端.7、桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
合成模式就是一个处理对象的树结构的模式。
合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
[b:9ceca65206]结构型模式[/b:9ceca65206]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：“我看上那辆法拉利跑车” 我脑袋嗡的一声，坐在椅子上，一咬牙：“我买，我买，还有吗？” …… 迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。
多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。
迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。
迭代子模式简化了聚集的界面。