GoF 的 23 种设计模式的分类和功能
UML-GoF设计模式
UML-GoF设计模式我认为，本章是重点中的重点。
并⾮23个模式都被⼴泛应⽤，其中常⽤和最为有效的⼤概有15个模式。
1、适配器（Adapter）1）、使⽤场景使⽤⼀个已经存在的类，但如果他的接⼝，也就是他的⽅法和你的要求不相同时，考虑使⽤是适配器模式。
就是说，双⽅都不修改⾃⼰的代码的时候，可以采⽤适配器模式。
2）、结构图3）、相关模式外观对象：隐藏外部系统的资源适配器也被视为外观对象，因为资源适配器使⽤单⼀对象封装了对⼦系统或系统的访问。
资源适配器：当包装对象时为不同外部接⼝提供适配时，该对象叫资源适配器4）、准则类名后缀为“Adapter”。
5）、⽤到的GRASP原则2、⼯⼚模式1）、使⽤场景该模式也常称为“简单⼯⼚”或“具体⼯⼚”。
如：1）、存在复杂创建逻辑2）、为提⾼内聚⽽分离创建者职责（关注点分离）因此，创建称为⼯⼚的纯虚构对象来处理这些创建职责。
2）、结构⼀般xxxFactory应该是单实例类。
3）、相关模式通常使⽤单例模式来访问⼯⼚模式。
由谁创建⼯⼚呢？⼀般采⽤单例模式。
3、单例模式1）、使⽤场景只有唯⼀实例的类即为“单实例类”。
对象需要全局可见性和单点访问。
因此，建议对类定义静态⽅法⽤以返回单实例。
2）、相关模式单例模式：通常⽤于创建⼯⼚对象和外观对象以上整合例⼦：4、策略模式1）、使⽤场景销售的定价策略（也可叫做规则、政策或算法）具有多样性。
在⼀段时间内，对于所有的销售可能会有10%的折扣，后期可能会对超出200元的销售给予10%的折扣，并且还会存在其他⼤量的变化。
因此，在单独的类中分别定义每种策略/规则/政策/算法，并且使其具有共同接⼝。
2 ）、结构策略模式，共同的⽅法内传⼊的参数，通常是上下⽂对象，上图就是sale。
3）、结合⼯⼚模式1）、使⽤⼯⼚模式创建这些策略类2）、使⽤单例模式创建⼯⼚类。
5、组合模式1）、使⽤场景如果有重叠怎么办？⽐如：1）⽼年⼈折扣20%2）购物⾦额满200元享受15%折扣因此，如何能够处理像原⼦对象⼀样，（多态的）处理⼀组对象或具有组合结构的对象呢？答：定义组合和原⼦对象的类，使他们具有相同的接⼝。
GOF以及JAVA的23种设计模式简介
GOF以及java的23种设计模式简介GoF:（Gang of Four，GOF设计模式）---四人组Design Patterns:Elements of Reusable Object-Oriented Software（即后述《设计模式》一书），由Erich Gamma、Richard Helm、Ralph Johnson 和John Vlissides合著（Addison-Wesley，1995）。
这几位作者常被称为"四人组（Gang of Four）"，而这本书也就被称为"四人组（或GoF）"书。
Design Patterns:Elements of Reusable Object-Oriented Software（即后述《设计模式》一书），由Erich Gamma、Richard Helm、Ralph Johnson 和John Vlissides合著（Addison-Wesley，1995）。
这几位作者常被称为“四人组（Gang of Four）”，而这本书也就被称为“四人组（或GoF）”书。
在《设计模式》这本书的最大部分是一个目录，该目录列举并描述了23种设计模式。
另外，近来这一清单又增加了一些类别，最重要的是使涵盖范围扩展到更具体的问题类型。
例如，Mark Grand在Patterns in Java:A Catalog of Reusable Design Patterns Illustrated with UML（即后述《模式Java版》一书）中增加了解决涉及诸如并发等问题的模式，而由Deepak Alur、John Crupi和Dan Malks合著的Core J2EE Patterns:Best Practices and Design Strategies一书中主要关注使用Java2企业技术的多层应用程序上的模式。
对软件设计模式的研究造就了一本可能是面向对象设计方面最有影响的书籍：《设计模式》。
GOF_23种设计模式
创建型模式1、FACTORY2、BUILDER3、FACTORY METHOD4、PROTOTYPE5、SINGLETON结构型模式6、ADAPTER7、BRIDGE8、COMPOSITE9、DECORATOR10、FAÇADE11、FLYWEIGHT12、PROXY行为模式13、CHAIN OF RESPONSIBLEITY14、COMMAND15、INTERPRETER16、ITERATOR17、MEDIATOR18、MEMENTO19、OBSERVER20、STATE21、STRATEGY22、TEMPLATE METHOD23、VISITOR创建型模式1、FACTORY追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。
麦当劳和肯德基就是生产鸡翅的Factory工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、BUILDERMM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。
（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、FACTORY METHOD请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
ch07-应用GoF设计模式(第26章)
图26-5 工厂模式
工厂模式（Factory）引发的 新的设计问题
ServicesFactory 引起了一个新的设计问题： 谁来创建Factory本身呢？如何调用它呢？
应注意到在处理过程中只需要ServicesFactory的一个 实例。 • 编码中，ServicesFactory的方法需要在许多地方被调 用（由于ServicesFactory创建相应的Adapter， Adapter 调用外部服务系统）
UML表示法：这里的“1”是可选的，用于 表示只有一个实例能够被创建（单实例类）
1 ServicesFactory
UML表示法：在类 框图中，带有下划 线的属性或方法表 示（类级别）静态 成员而不是实例成 员
instance : ServicesFactory accountingAdapter : IAccountingAdapter inventoryAdapter : IInventoryAdapter taxCalculatorAdapter : ITaxCalculatorAdapter getInstance() : ServicesFactory getAccountingAdapter() : IAccountingAdapter getInventoryAdapter() : IInventoryAdapter getTaxCalculatorAdapter() : ITaxCalculatorAdapter ...
Contains
新发现的类型
图26-4 更新后的部分领域模型
适配器模式引发了一个新的设计问题
由谁来创建Adapter呢？ 如何确定创建哪个Adapter子类？例如，SAPAccountingAdapter 还是 GreatNorthernAccountingAdapter
GOF的23种设计模式
GOF的23种设计模式一、创建型模式Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
Builder：将一个复杂对象的构件与它的表示分离，使得同样的构建过程可以创建不同的表述。
Factory Method：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
Factory Method使一个类的实例化延迟到其子类。
Prototype：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
Singleton：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
二、结构型模式Adapter：将一个类的接口转换成客户希望的另外一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
Composite：将对象组合成树型结构以表示“部分－整体”的层次结构。
Composite使得客户对单个对象和复合对象的使用具有一致性。
Decorator：动态地给一个对象添加一些额外的职责。
就扩展功能而言，Decorator模式比生成子类方式更为灵活。
Facade：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
Flyweight：运用共享技术有效地支持大量细粒度的对象。
Proxy：为其他对象提供一个代理以控制对这个对象的访问。
三、行为型模式Chain of Responsibility：为解除请求的发送者和接受者之间耦合，而使多个对象都有机会处理这个请求。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。
Command：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。
Interpreter：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
23种设计模式及应用
23种设计模式及应用设计模式是指在软件设计过程中，针对常见问题的解决方案的经验总结。
它们提供了解决特定或常见问题的可重用方案，使得软件设计更加灵活、可扩展和可维护。
1. 创建型模式：- 单例模式：确保一个类只有一个实例，并提供全局访问点。
- 简单工厂模式：通过一个共同的接口创建不同的对象实例。
- 工厂方法模式：定义一个创建对象的接口，由子类决定具体创建哪个对象。
- 抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口。
- 建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
2. 结构型模式：- 适配器模式：将一个类的接口转换为客户端所期待的另一种接口。
- 桥接模式：将抽象部分与它的实现部分分离，使它们可以独立变化。
- 组合模式：将对象组合成树形结构以表示"整体-部分"的层次结构。
- 装饰器模式：动态地给对象添加额外的功能，避免继承带来的类膨胀问题。
- 外观模式：为子系统中一组接口提供一个一致的界面。
3. 行为型模式：- 策略模式：定义一系列算法，将它们封装起来，并使它们可以相互替换。
- 观察者模式：定义对象之间的依赖关系，当对象状态改变时自动通知依赖方。
- 模板方法模式：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。
- 命令模式：将一个请求封装成一个对象，从而使您可以用不同的请求参数化客户端对象。
- 状态模式：允许对象在其内部状态改变时改变其行为。
4. J2EE模式：- MVC模式：将应用程序划分为三个核心组件：模型、视图和控制器。
- 业务代表模式：将对业务对象的访问和业务逻辑从表示层分离出来。
- 数据访问对象模式：用于将业务逻辑和数据访问逻辑分离。
- 前端控制器模式：通过一个单一的入口点来处理应用程序的所有请求。
- 传输对象模式：用于在客户端和服务器之间传输数据。
5. 并发模式：- 线程池模式：创建一组预先初始化的线程对象来处理任务。
Java设计模式之GOF23全面讲解
Java设计模式之GOF23全⾯讲解⼀、什么是设计模式设计模式（Design pattern）是解决软件开发某些特定问题⽽提出的⼀些解决⽅案也可以理解成解决问题的⼀些思路。
通过设计模式可以帮助我们增强代码的可重⽤性、可扩充性、可维护性、灵活性好。
我们使⽤设计模式最终的⽬的是实现代码的⾼内聚和低耦合。
⼆、设计模式的三⼤分类及关键点1、创建型模式对象实例化的模式，创建型模式⽤于解耦对象的实例化过程。
单例模式：某个类智能有⼀个实例，提供⼀个全局的访问点。
⼯⼚模式：⼀个⼯⼚类根据传⼊的参量决定创建出哪⼀种产品类的实例。
抽象⼯⼚模式：创建相关或依赖对象的家族，⽽⽆需明确指定具体类。
建造者模式：封装⼀个复杂对象的创建过程，并可以按步骤构造。
原型模式：通过复制现有的实例来创建新的实例。
2、结构型模式把类或对象结合在⼀起形成⼀个更⼤的结构。
装饰器模式：动态的给对象添加新的功能。
代理模式：为其它对象提供⼀个代理以便控制这个对象的访问。
桥接模式：将抽象部分和它的实现部分分离，使它们都可以独⽴的变化。
适配器模式：将⼀个类的⽅法接⼝转换成客户希望的另⼀个接⼝。
组合模式：将对象组合成树形结构以表⽰“部分-整体”的层次结构。
外观模式：对外提供⼀个统⼀的⽅法，来访问⼦系统中的⼀群接⼝。
享元模式：通过共享技术来有效的⽀持⼤量细粒度的对象。
3、⾏为型模式类和对象如何交互，及划分责任和算法。
策略模式：定义⼀系列算法，把他们封装起来，并且使它们可以相互替换。
模板模式：定义⼀个算法结构，⽽将⼀些步骤延迟到⼦类实现。
命令模式：将命令请求封装为⼀个对象，使得可以⽤不同的请求来进⾏参数化。
迭代器模式：⼀种遍历访问聚合对象中各个元素的⽅法，不暴露该对象的内部结构。
观察者模式：对象间的⼀对多的依赖关系。
仲裁者模式：⽤⼀个中介对象来封装⼀系列的对象交互。
备忘录模式：在不破坏封装的前提下，保持对象的内部状态。
解释器模式：给定⼀个语⾔，定义它的⽂法的⼀种表⽰，并定义⼀个解释器。
gof 23 种设计模式解析附 c语言
gof 23 种设计模式解析附 c语言在计算机科学中，设计模式（Design Patterns）是一套被反复使用的，多数人知道的，经过分类编目的，代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
GoF 23种设计模式是设计模式中最经典和最常用的部分，这些模式主要用于解决特定类型的问题。
下面是这些设计模式的C语言解析：1. 工厂方法模式（Factory Method Pattern）```c#include <stdio.h>// 抽象产品类struct AbstractProduct {void use() {printf("AbstractProduct\n");}};// 具体产品类1struct ConcreteProduct1 : public AbstractProduct { void use() {printf("ConcreteProduct1\n");}};// 具体产品类2struct ConcreteProduct2 : public AbstractProduct { void use() {printf("ConcreteProduct2\n");}};// 抽象工厂类struct AbstractFactory {virtual AbstractProduct* createProduct() = 0; };// 具体工厂类1struct ConcreteFactory1 : public AbstractFactory {AbstractProduct* createProduct() {return new ConcreteProduct1;}};// 具体工厂类2struct ConcreteFactory2 : public AbstractFactory {AbstractProduct* createProduct() {return new ConcreteProduct2;}};int main() {ConcreteFactory1 factory1;ConcreteProduct1* product1 = factory1.createProduct(); product1->use(); // 输出 "ConcreteProduct1"delete product1; // 释放内存factory1.createProduct(); // 空指针异常，因为工厂已不再生产任何产品return 0;}```。
23种设计模式记忆口诀
23种设计模式记忆口诀根据内容要求，对23种设计模式进行简要说明，并整理成口诀。
设计模式是软件开发中常用的一种解决方案，它提供了面向对象设计和编程中常见问题的解决思路和方法。
根据GoF（Gang of Four）的分类，设计模式可以分为创建型、结构型和行为型三种类型，共23种设计模式。
1. 创建型模式（Creational Patterns）：- 工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但由子类决定实例化的类。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关对象或依赖对象的接口，而无须指定它们的具体类。
- 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
- 原型模式（Prototype Pattern）：用于创建重复性对象的一个原型。
- 建造者模式（Builder Pattern）：将一个复杂对象的构建和表示分离，使得同样的构建过程可以创建不同的表示。
2. 结构型模式（Structural Patterns）：- 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
- 桥接模式（Bridge Pattern）：将抽象部分和它真正的实现分离，使它们独立的变化。
- 装饰器模式（Decorator Pattern）：动态地将责任附加到对象上，扩展功能。
- 外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口，以简化系统的使用。
3. 行为型模式（Behavioral Patterns）：- 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并使它们可以相互替换。
- 模板方法模式（Template Method Pattern）：定义一个算法的骨架，由子类实现具体步骤。
.netgof23种设计模式
.netgof23种设计模式⼀、设计模式的分类GOF⼀共总结了23套设计模式，⼤致可以分为以下三类：创造型模式这些设计模式提供了⼀种在创建对象的同时隐藏创建逻辑的⽅式，⽽不是使⽤ new 运算符直接实例化对象。
这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活，该类型包括：单件模式、抽象⼯⼚、建造者模式、⼯⼚⽅法模式和原型模式等5种。
结构型模式这些设计模式关注类和对象的组合。
继承的概念被⽤来组合接⼝和定义组合对象获得新功能的⽅式，该类型包括：适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式和代理模式等7种。
⾏为型模式这些设计模式特别关注对象之间的通信。
分为职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板⽅法、访问者模式等11种。
⼆、设计模式解析常⽤设计模式浅析：1、单件模式结构图：意图：保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点。
适⽤性：当类只能有⼀个实例⽽且客户可以从⼀个众所周知的访问点访问它时。
当这个唯⼀实例应该是通过⼦类化可扩展的，并且客户应该⽆需更改代码就能使⽤⼀个扩展的实例时。
⽰意性代码：1//单件模式⽰意性代码2public class Singleton3 {4//创建私有对象，保证只有⼀个对象5private static Singleton _instance;67//保护类型的构造函数，⼦类化可扩展8protected Singleton() { }910//提供公共访问点11public static Singleton Instance()12 {1314// 使⽤ 'Lazy initialization'，为对象实例化15if (_instance == null)16 {17 _instance = new Singleton();18 }1920return _instance;21 }22 }Singleton特点总结：实例对外唯⼀、⼦类可以扩展并且提供⼀个公共的访问点访问。
设计模式系列之一：23种GoF设计模式概述
设计模式系列之一：23种GoF设计模式概述23种GoF设计模式概述在前面，我们对 GoF 的 23 种设计模式进行了分类，这里先对各个设计模式的功能进行简要介绍，以便有个大概了解。
后面的章节再进行详细介绍。
创建型模式关注于怎么创建对象的创建型模式，他们将对象的创建与使用相互分离，对象的使用者无需关心如何创建对象，只知道怎么使用就行，以降低耦合度。
犹如汽车使用人无需关注汽车是怎么造出来一样，只要知道怎么使用就行。
下面这5种模式就是属于这一类。
•单例（Singleton）模式：控制某个类只能自行生成一个可供外部全局访问的实例。
例如：Windows的窗口管理器或者任务管理器都是只有一个实例。
•原型（Prototype）模式：将一个创建成本高（如：装载大文件、初始化耗时长、CPU资源占用多等）的对象作为原型，通过对其进行复制或者克隆，来创建其他类似的新实例。
•抽象工厂（Abstract Factory）模式：由继承自抽象工厂类的具体工厂分别来创建有相同联系的多个不同产品。
例如不同的培训学校，可以创建课程和课程所用的教材。
•建造者（Builder）模式：针对一个复杂对象，它的构建需要很多步骤和部件，将这种对象拆解成多个相对简单的构成部件或者步骤，然后再根据需要分别构建他们，直到得到该复杂对象。
例如：快餐店的套餐，他的构造分别由汉堡、饮料、薯条构成，这就要求建造或制作者分别创建各种物品，然后返回一个完整的套餐给点餐人员。
•工厂方法（Factory Method）模式：由继承自抽象工厂类的具体工厂来决定生成什么具体产品。
例如都属于家具厂的沙发工厂、桌椅工厂和床厂分别生产沙发、桌椅和床这些家具。
结构型模式这种模式关注如何将对象和类按照某种方式一起来构成新的、更大、更有效果的低耦合结构，这种组成方式用于类结构的继承、和用于对象结构的组合或聚合。
具有组合或聚合关系的各对象之间要比继承关系的各对象之间的耦合度弱，这样对象结构要比类对象具有更低的耦合度。
二十三种设计模式
B. 结构模式 设计模式之 Adapter(适配器) 使用类再生的两个方式:组合(new)和继承(extends),这个已经在 thinking in java 中提到过. 设计模式之 Proxy(代理) 以 Jive 为例,剖析代理模式在用户级别授权机制上的应用 设计模式之 Facade(门面？) 可扩展的使用 JDBC 针对不同的数据库编程,Facade 提供了一种灵活的实现. 设计模式之 Composite(组合) 就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于 和单位做买卖。文章中还对 Jive 再进行了剖析。 设计模式之 Decorator(装饰器) Decorator 是个油漆工,给你的东东的外表刷上美丽的颜色. 设计模式之 Bridge(桥连) 将牛郎织女分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合) 设计模式之 Flyweight(共享元) 提供 Java 运行性能,降低小而大量重复的类的开销.
可以这么说：GoF 设计模式是程序员真正掌握面向对象核心思想的必修课。虽然你可能已经通过了 SUN 的很多令人炫目的 技术认证，但是如果你没有学习掌握 GoF 设计模式，只能说明你还是一个技工。
在浏览《Thingking in Java》(第一版)时，你是不是觉得好象这还是一本 Java 基础语言书籍？但又不纯粹是，因为这本书的作 者将面向对象的思想巧妙的融合在 Java 的具体技术上，潜移默化的让你感觉到了一种新的语言和新的思想方式的诞生。
C. 行为模式 设计模式之 Command(命令) 什么是将行为封装,Command 是最好的说明. 设计模式之 Observer(观察者) 介绍如何使用 Java API 提供的现成 Observer 设计模式之 Iterator(迭代器) 这个模式已经被整合入 Java 的 Collection.在大多数场合下无需自己制造一个 Iterator,只要将对象装入 Collection 中， 直接使用 Iterator 进行对象对书中这些蕴含的思想也许需要一种更明晰更系统更透彻的了解和掌握，那么你就需要研读 GoF 的《设 计模式》了。
设计模式-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架构；银⾏⽇志管理：格式分类：操作⽇志、交易⽇志、异常⽇志距离分类：本地记录⽇志、异地记录⽇志⼈⼒资源系统中的奖⾦计算模块：奖⾦分类：个⼈奖⾦、团体奖⾦、激励奖⾦。
盘点GoF的23种设计模式
盘点GoF的23种设计模式前⾔设计模式最初并⾮出于软件设计中，⽽是⽤于建筑领域的设计中。
1995年，四位作者将建筑设计的基本模式融合到软件开发中，合作出版了《设计模式：可复⽤的⾯向对象软件的基础》，⼀共收录了23个设计模式，这是设计模式领域⾥程碑的事件，导致了软件设计模式的突破。
所以这四位作者在软件开发领域耦以四⼈帮（Gang Of Four）匿名著称，简称GoF。
⼀、设计模式的分类设计模式按照⽬的来划分的话可以划分为三种类型，分别为创建型模式、结构型模式和⾏为型模式1.1、创建型模式⽤于描述“怎样创建对象”，主要特点是将对象的创建和使⽤进⾏分离。
对象使⽤者不需要关⼼对象的创建细节，可以降低创建对象和使⽤对象之间的耦合度。
主要有单例模式、原型模式、⼯⼚⽅法模式、抽象⼯⼚模式和建造者模式等五种设计模式1.2、结构型模式⽤于描述如何将类或对象按某种布局组成更⼤的结构主要有代理模式、适配器模式、桥接模式、装饰器模式、外观模式、享元模式和组合模式等七种设计模式1.3、⾏为型模式⽤于描述类或对象之间怎样协作共同完成单个对象都⽆法单独完成的任务以及如何分配各个对象的职责分配主要有模版⽅法模式、策略模式、命令模式、责任链模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式和解释器模式等⼗⼀中设计模式⼆、创建型设计模式2.1、单例模式（Singleton）定义：某个类只能⽣成⼀个实例，该类需要提供⼀个全局访问点供外部获取该类的全局唯⼀实例单例模式的类需要满⾜以下三个要求：1.单例类只有⼀个实例对象2.单例对象必须由单例类⾃⾏创建3.单例类需要对外提供⼀个获取单例对象的全局访问点优缺点：1、保证内存中仅有⼀个实例，减少内存开销2、不易扩展，需求发⽣改变需要修改单例类，会违背开闭原则应⽤场景：1、需要频繁创建和销毁某个类的实例时;2、某个类的实例具有唯⼀性时3、类的创建实例的过程⾮常消耗资源时4、对象需要被全局共享时可参考⽂章：2.2、原型模式（Prototype）定义：将⼀个对象作为原型，通过对其复制从⽽克隆出多个和原型类似的新的实例优缺点：1、采⽤clone的⽅式⽐new⼀个对象性能更好，因为是直接基于内存⼆进制流的复制2、深克隆时需要每⼀层的对象都需要实现cloneable接⼝原型模式在Java中的实现依赖于cloneable接⼝，原型实现cloneable接⼝，需要根据原型创建新对象时，直接调⽤原型对象的clone⽅法进⾏复制即可应⽤场景：1、对象之间相同或相似时，⽆需通过new创建2、创建对象成本⼤，⽐如⽐较消耗CPU或⽹络资源等3、系统中⼤量使⽤该类对象，且各个调⽤者都需要给它的属性重写赋值时，⽐如状态等属性案例如下：业务场景⽃地主游戏有3⼈⽃地主和4⼈⽃地主，每种模式还分为新⼿房和⾼⼿房，此时可以抽象出游戏房间的类，并初始化各种类型的房间原型，每当有玩家进⼊对应模式的房间时就通过原型直接复制出⼀个房间即可。
设计模式精解-GOF23种设计模式解析(VS2012重写实现包含Linux Makefile) 代码和原文档已插入本文档
设计模式笔记（C++）一、创建型Factory：工厂1、定义创建对象的接口，封装了对象的创建2、使得具体化类的工作延迟到了子类中3、Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或者延迟对象的创建到子类中实现。
AbstractFactory：抽象工厂1、创建一组相关或者相互依赖的对象2、AbstractFactory模式是为创建一组（有多类）相关或者依赖的对象提供创建接口3、AbstractFactory模式通常都是使用Factory模式实现（ConcreateFactroy）Singleton：单例1、Singleton模式保证一个类仅有一个对象，并提供一个访问它的全局访问点。
2、全局变量不能防止实例化多个对象。
3、全局变量将使得对象在无论是否用到都要被创建。
Builder：创建者1、Builder模式的意图是非常容易理解、间接的：将一个复杂对象的构建与它的表示分离，使用同样的构建过程可以创建不同的表示（在示例代码中可以通过传入不同的参数实现这一点）。
Builder模式和AbstractFactory模式在功能上很相似，因为都是创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。
而在AbstractFactory 模式中对象是直接返回的，AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。
Prototype：原型1、Prototype模式通过复制原型（Prototype）而获得新对象创建的功能，这里Prototype本身就是“对象工厂”（因为能够生产对象），实际上Prototype 模式和Builder模式、AbstractFactory模式都是通过一个类（对象实例）来专门负责对象的创建工作（工厂对象），它们之间的区别是：Builder模式重在复杂对象的一步步创建（并不直接返回对象），AbstractFactory模式重在产生多个相互依赖的对象，而Prototype模式重在从自身复制自己创建新类。
GangOfFour的23中设计模式
GangOfFour的23中设计模式Gang Of Four的23中设计模式标签（空格分隔）： 设计模式1. 根据⽬的来进⾏划分根据⽬的进⾏划分可以分为创建型模式, 结构型模式和⾏为模式三种.1.1 创建型模式怎样创建对象, 主要特点是将对象的创建和使⽤分离, GoF中提供了单例, 原型, ⼯⼚⽅法, 抽象⼯⼚, 建造者等5中创建型模式.1.2 结构性模式⽤于描述如何将类或者对象按照某种布局组成更⼤的结构, GoF提供了代理, 适配器, 桥接, 外观, 享元, 组合等6中结构性模式.1.3 ⾏为模式⽤于描述类或对象之间如何通过写作共同完成单个对象⽆法完成的任务, 以及怎样分配职责. GoF中提供了模板⽅法, 策略, 命令, 职责链, 状态, 观察者, 中介者, 迭代者, 访问者, 备忘录, 解释器.GoF的23中设计模式的功能(只列出常见的).单例(Singleton)模式: 某个类只能⽣成⼀个实例, 该类提供了⼀个全局访问点供外部获取该实例拓展是有限多例模式.原型(Prototype)模式: 将⼀个对象作为原型, 通过对其进⾏复制⽽克隆出多个和原型类似的新实例.⼯⼚(Factory)⽅法: 定义⼀个⽤于创建产品的接⼝, 由⼦类决定⽣产什么产品.抽象⼯⼚(AbstractFactory)模式: 提供⼀个创建产品族的接⼝, 其每个⼦类可以⽣产⼀系列相关的产品.代理(Proxy)模式: 为某对象提供⼀种代理以控制对该对象的访问, 即客户端通过代理间接的访问该对象, 从⽽限制, 增强或者修改该对象的⼀些特性.适配器(Adapter)模式: 将⼀个类的接⼝转换成客户希望的另⼀个接⼝, 使得原本由于接⼝不兼容⽽不能⼀起⼯作的哪些类⼀起⼯作.桥接(Bridge)模式: 将抽象和实现分离, 它他们可以独⽴变化, 他们使⽤组合关系替代竭诚关系来实现, 从⽽降低了抽象和实现这两个可变维度的耦合度.装饰(Decorator)模式: 动态的给对象增加⼀些功能.享元(Flyweight)模式: 运⾏共享技术来有效的⽀持⼤量细粒度对象的复⽤.策略(Strategy)模式: 定义了⼀些列的算法, 并且将每个算法封装起来, 使他们可以相互替换, 且算法的改变不会影响使⽤算法的客户.模板⽅法（TemplateMethod）模式：定义⼀个操作中的算法⾻架，⽽将算法的⼀些步骤延迟到⼦类中，使得⼦类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
GOF23种设计模式详解-tony
} public interface Driver{ Car driveCar();
第 5 / 89 页
1.1 设计模式之略见一斑(工厂模式Factory)
} public class QQDriver implements Driver{ public Car driveCar() { return new QQCar(); } } public class BaoMaDriver implements Driver{ public Car driveCar() { return new BaoMaCar(); } } public class BenChiDriver implements Driver{ public Car driveCar() { return new BenChiCar(); } }
- 做最棒的软件开发交流社区
21种设计模式详解
作者: 行者买刀
行者买刀的博客文章精选 如有疑问或建议请站内短信联系
第 1 / 89 页
本书由JavaEye提供的电子书DIY功能自动生成于 2010-02-26
1.2 设计模式之略见一斑(单例模式singleton)
发表时间: 2010-02-01 单例模式是属于比较常用的一例，一个类（class）在内存中只有一个实例。 常用方式如下: 第一种（饿汉式）：
public class Singleton {
1.1 设计模式之略见一斑(工厂模式Factory)
如此基础上对新式的各种各样的车进行区别，从而当新增一款车型时或者新增一类车型时就对应加入相应的类 和方法
第(单例模式singleton)
目录
1. J2SE
1.1 设计模式之略见一斑(工厂模式Factory) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.2 设计模式之略见一斑(单例模式singleton) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 1.3 设计模式之略见一斑(建造模式builder) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.4 设计模式之略见一斑(原型模式Prototype) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.5 设计模式之略见一斑(适配器模式Adapter) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.6 设计模式之略见一斑(桥梁模式bridge) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 1.7 设计模式之略见一斑(外观模式Facade) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.8 设计模式之略见一斑(组合模式Composite) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.9 设计模式之略见一斑(装饰模式decorator) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 1.10 设计模式之略见一斑(代理模式Proxy) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 1.11 设计模式之略见一斑(享元模式flyweight) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 1.12 设计模式之略见一斑(命令模式Command) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 1.13 设计模式之略见一斑(解释器模式Interpreter) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 1.14 设计模式之略见一斑(状态模式State) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 1.15 设计模式之略见一斑(策略模式strategy) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.16 设计模式之略见一斑(Template Method模板方法模式) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 1.17 设计模式之略见一斑(Memento备忘录模式) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 1.18 设计模式之略见一斑(Observer观察者模式) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 1.19 设计模式之略见一斑(Chain of Responsibility责任链模式) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
模式分类——精选推荐
模式分类GOF23模式分类从⽬的来分：创建型（Creational）模式：将对象的部分创建⼯作延迟到⼦类或者其他对象，从⽽应对需求变化为对象创建时具体类型实现引来的冲击结构型（Structural）模式：通过类继承或者对象组合获得更灵活的结构，从⽽应对需求变化为对象的结构带来的冲击⾏为型（Behavioral）模式：通过类继承或者对象组合来划分类与对象的职责，从⽽应对需求变化为多个交互的对象带来的冲击从范围来分：类模式处理类与⼦类的静态关系对象模式处理对象间的动态关系从封装变化⾓度对模式分类组件协作：现代软件专业分⼯之后的第⼀个结构是"框架与应⽤程序的划分"，"组件协作"模式通过晚期绑定，来实现框架与应⽤程序之间的松耦合，是是⼆者之间协作时常⽤的模式Template Method模板⽅法Strategy策略模式Observer/Event事件模式单⼀职责：类与类责任划分DecoratorBridge对象创建：对象创建依赖关系Factory MethodAbstract FactoryPrototypeBuilder对象性能：SingletonFlyweight接⼝隔离：FacadeProxyMediatorAdapter状态变化：MementoState数据结构：CompositeIteratorChain of Responsibility⾏为变化：CommandVisitor领域问题：Interpreter重构获得模式Refactoring to Patterns⾯向对象设计模式是"好的⾯向对象设计"指可以满⾜"应对变化，提⾼复⽤"的设计现代软件设计的特征是"需求的频繁变化"设计模式的要点是"寻求变化点"在变化点点处应⽤设计模式，从⽽来更好的应对需求的变化"，"什么时候，什么地点应⽤设计模式"⽐"理解设计模式结构本⾝"更为重要设计模式的应⽤不宜先⼊为主，⼀上来就使⽤设计模式，对设计模式的最⼤误⽤没有⼀步到位的设计模式敏捷软件开发实践所提倡的"Refactoring to Patterns"是⽬前普遍公认的最好的使⽤设计模式的⽅法重构的技法静态 -> 动态早绑定 -> 晚绑定继承 -> 组合编译时依赖 -> 运⾏时依赖紧耦合 -> 松耦合。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
GoF 的23 种设计模式的分类和功能
文档修订摘要
目录
GoF 的23 种设计模式的分类和功能 (1)
1. 概述 (4)
1.1. 阅读对象 (4)
1.2. 名词解释 (4)
1.3. 来源网站 (4)
2. 详细说明 (4)
(4)
2.1. 根据目的来分 (4)
2.2. 根据作用范围来分 (4)
2.3. GoF的23种设计模式的功能 (5)
1.概述
1.1.阅读对象
无
1.2.名词解释
无
1.3.来源网站
2.详细说明
2.1.根据目的来分
根据模式是用来完成什么工作来划分，这种方式可分为创建型模式、结构型模式和行为型模式 3 种。
创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。
GoF 中提供了单例、原型、工厂方法、抽象工厂、建造者等5 种创建型模式。
结构型模式：用于描述如何将类或对象按某种布局组成更大的结构，GoF 中提供了代理、适配器、桥接、装饰、外观、享元、组合等7 种结构型模式。
行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。
GoF 中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等11 种行为型模式。
2.2.根据作用范围来分
根据模式是主要用于类上还是主要用于对象上来分，这种方式可分为类模式和对象模式两种。
类模式：用于处理类与子类之间的关系，这些关系通过继承来建立，是静态的，在编译时刻便确定下来了。
GoF中的工厂方法、（类）适配器、模板方法、解释器属于该模式。
对象模式：用于处理对象之间的关系，这些关系可以通过组合或聚合来实现，在运行时刻是可以变化的，更具动态性。
GoF 中除了以上4 种，其他的都是对象模式。
表1 介绍了这23 种设计模式的分类。
2.3.GoF的23种设计模式的功能
前面说明了GoF 的23 种设计模式的分类，现在对各个模式的功能进行介绍。
单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。
即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。
它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
装饰（Decorator）模式：动态的给对象增加一些职责，即增加其额外的功能。
外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。
模板方法（TemplateMethod）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互
替换，且算法的改变不会影响使用算法的客户。
命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
职责链（Chain of Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。
通过这种方式去除对象之间的耦合。
状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。
必须指出，这23 种设计模式不是孤立存在的，很多模式之间存在一定的关联关系，在大的系统开发中常常同时使用多种设计模式，希望读者认真学好它们。