Gof的23种设计模式

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:（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企业技术的多层应用程序上的模式。

对软件设计模式的研究造就了一本可能是面向对象设计方面最有影响的书籍：《设计模式》。

创建型模式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直接跟服务员说就行了。

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：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

Java设计模式之GOF23全⾯讲解⼀、什么是设计模式设计模式（Design pattern）是解决软件开发某些特定问题⽽提出的⼀些解决⽅案也可以理解成解决问题的⼀些思路。

通过设计模式可以帮助我们增强代码的可重⽤性、可扩充性、可维护性、灵活性好。

我们使⽤设计模式最终的⽬的是实现代码的⾼内聚和低耦合。

⼆、设计模式的三⼤分类及关键点1、创建型模式对象实例化的模式，创建型模式⽤于解耦对象的实例化过程。

单例模式：某个类智能有⼀个实例，提供⼀个全局的访问点。

⼯⼚模式：⼀个⼯⼚类根据传⼊的参量决定创建出哪⼀种产品类的实例。

抽象⼯⼚模式：创建相关或依赖对象的家族，⽽⽆需明确指定具体类。

建造者模式：封装⼀个复杂对象的创建过程，并可以按步骤构造。

原型模式：通过复制现有的实例来创建新的实例。

2、结构型模式把类或对象结合在⼀起形成⼀个更⼤的结构。

装饰器模式：动态的给对象添加新的功能。

代理模式：为其它对象提供⼀个代理以便控制这个对象的访问。

桥接模式：将抽象部分和它的实现部分分离，使它们都可以独⽴的变化。

适配器模式：将⼀个类的⽅法接⼝转换成客户希望的另⼀个接⼝。

组合模式：将对象组合成树形结构以表⽰“部分-整体”的层次结构。

外观模式：对外提供⼀个统⼀的⽅法，来访问⼦系统中的⼀群接⼝。

享元模式：通过共享技术来有效的⽀持⼤量细粒度的对象。

3、⾏为型模式类和对象如何交互，及划分责任和算法。

策略模式：定义⼀系列算法，把他们封装起来，并且使它们可以相互替换。

模板模式：定义⼀个算法结构，⽽将⼀些步骤延迟到⼦类实现。

命令模式：将命令请求封装为⼀个对象，使得可以⽤不同的请求来进⾏参数化。

迭代器模式：⼀种遍历访问聚合对象中各个元素的⽅法，不暴露该对象的内部结构。

观察者模式：对象间的⼀对多的依赖关系。

仲裁者模式：⽤⼀个中介对象来封装⼀系列的对象交互。

备忘录模式：在不破坏封装的前提下，保持对象的内部状态。

解释器模式：给定⼀个语⾔，定义它的⽂法的⼀种表⽰，并定义⼀个解释器。

面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。

在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。

本文将对23种常见的设计模式进行详解。

一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。

在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。

简单工厂模式适合于对象创建过程较为简单的情况。

2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。

工厂方法模式适合于对象创建过程较为复杂的情况。

它可以为工厂类添加新的产品类型，而不会影响原有的代码。

3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。

在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。

4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。

在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。

5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。

在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。

原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。

二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。

在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。

7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。

23种设计模式记忆口诀
1.单例模式：唯一实例化，静态访问，线程不安全
2. 工厂方法模式：子类实现，工厂创建，扩展性强
3. 抽象工厂模式：创建一族产品，接口约束，扩展性强
4. 建造者模式：组合复杂对象，分步骤构建，灵活性高
5. 原型模式：克隆对象，避免重复创建，效率高
6. 适配器模式：兼容接口不同，类似转换器，易扩展
7. 桥接模式：抽象与实现分离，解耦合，易扩展
8. 装饰器模式：动态增强对象功能，不影响原有对象，易扩展
9. 组合模式：层次结构，统一访问，易扩展
10. 外观模式：简化复杂系统调用，易使用，易扩展
11. 享元模式：共享资源，避免重复创建，效率高
12. 代理模式：增强对象功能，控制对象访问，易扩展
13. 责任链模式：多个对象处理请求，自动传递，易扩展
14. 命令模式：将请求封装成对象，易扩展，易记录日志
15. 解释器模式：解释语言，易扩展，易维护
16. 迭代器模式：遍历集合，统一访问，易扩展
17. 中介者模式：分离对象间交互，降低耦合，易扩展
18. 观察者模式：对象状态改变，通知观察者，易扩展
19. 备忘录模式：保存对象状态，易恢复，易扩展
20. 状态模式：对象状态改变，自动改变行为，易扩展
21. 策略模式：选择不同策略，易切换，易扩展
22. 模板方法模式：定义操作流程，易扩展，易维护
23. 访问者模式：统一访问集合中对象，易扩展，易维护。

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种设计模式进行简要说明，并整理成口诀。

设计模式是软件开发中常用的一种解决方案，它提供了面向对象设计和编程中常见问题的解决思路和方法。

根据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种设计模式⼀、设计模式的分类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设计模式概述在前面，我们对 GoF 的 23 种设计模式进行了分类，这里先对各个设计模式的功能进行简要介绍，以便有个大概了解。

后面的章节再进行详细介绍。

创建型模式关注于怎么创建对象的创建型模式，他们将对象的创建与使用相互分离，对象的使用者无需关心如何创建对象，只知道怎么使用就行，以降低耦合度。

犹如汽车使用人无需关注汽车是怎么造出来一样，只要知道怎么使用就行。

下面这5种模式就是属于这一类。

•单例（Singleton）模式：控制某个类只能自行生成一个可供外部全局访问的实例。

例如：Windows的窗口管理器或者任务管理器都是只有一个实例。

•原型（Prototype）模式：将一个创建成本高（如：装载大文件、初始化耗时长、CPU资源占用多等）的对象作为原型，通过对其进行复制或者克隆，来创建其他类似的新实例。

•抽象工厂（Abstract Factory）模式：由继承自抽象工厂类的具体工厂分别来创建有相同联系的多个不同产品。

例如不同的培训学校，可以创建课程和课程所用的教材。

•建造者（Builder）模式：针对一个复杂对象，它的构建需要很多步骤和部件，将这种对象拆解成多个相对简单的构成部件或者步骤，然后再根据需要分别构建他们，直到得到该复杂对象。

例如：快餐店的套餐，他的构造分别由汉堡、饮料、薯条构成，这就要求建造或制作者分别创建各种物品，然后返回一个完整的套餐给点餐人员。

•工厂方法（Factory Method）模式：由继承自抽象工厂类的具体工厂来决定生成什么具体产品。

例如都属于家具厂的沙发工厂、桌椅工厂和床厂分别生产沙发、桌椅和床这些家具。

结构型模式这种模式关注如何将对象和类按照某种方式一起来构成新的、更大、更有效果的低耦合结构，这种组成方式用于类结构的继承、和用于对象结构的组合或聚合。

具有组合或聚合关系的各对象之间要比继承关系的各对象之间的耦合度弱，这样对象结构要比类对象具有更低的耦合度。

设计模式-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种设计模式前⾔设计模式最初并⾮出于软件设计中，⽽是⽤于建筑领域的设计中。

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⼈⽃地主，每种模式还分为新⼿房和⾼⼿房，此时可以抽象出游戏房间的类，并初始化各种类型的房间原型，每当有玩家进⼊对应模式的房间时就通过原型直接复制出⼀个房间即可。

设计模式笔记（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中设计模式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种设计模式之⾏为型模式之观察者模式⼀、概述定义对象之间的⼀种⼀对多的依赖关系，当⼀个对象的状态发⽣改变时，所有依赖于它的对象都得到通知并被⾃动更新。

⼆、适⽤性1.当⼀个抽象模型有两个⽅⾯，其中⼀个⽅⾯依赖于另⼀⽅⾯的时候。

将这⼆者封装在独⽴的对象中以使它们可以各⾃独⽴地改变和复⽤。

2.当对⼀个对象的改变需要同时改变其它对象，⽽且不知道具体有多少对象需要改变的时候。

3.当⼀个对象必须通知其它对象，⽽它⼜不能假定其它对象是谁的时候。

三、参与者1.Subject（⽬标）：⽬标知道它的观察者。

可以有任意多个观察者观察同⼀个⽬标。

提供注册和删除观察者对象的接⼝。

2.Observer（观察者）：为那些在⽬标发⽣改变时需要获得通知的对象定义⼀个更新接⼝。

3.ConcreteSubject（具体⽬标）：将有关状态存⼊各ConcreteObserver对象。

当它的状态发⽣改变时,向它的各个观察者发出通知。

4.ConcreteObserver（具体观察者）：维护⼀个指向ConcreteSubject对象的引⽤。

存储有关状态，这些状态应与⽬标的状态保持⼀致。

实现Observer的更新接⼝以使⾃⾝状态与⽬标的状态保持⼀致。

四、类图五、⽰例Subject[java]1. package cn.lynn.observer;2.3. import java.util.ArrayList;4. import java.util.List;5.6. public abstract class Citizen {7.8. protected List<Policeman> polices;9.10. private String action = "normal";11.12. public String getAction() {13. return action;14. }15.16. public void setAction(String action) {17. this.action = action;18. }19.20. public void setPolices() {21. polices = new ArrayList<Policeman>();22. }23.24. public void register(Policeman police) {25. polices.add(police);26. }27.28. public void unregister(Policeman police) {29. polices.remove(police);30. }31.32. public abstract void notify(String action);33. }Observer[java]1. package cn.lynn.observer;2.3. public interface Policeman {4.5. public void setOut(Citizen citizen);6.7. }ConcreteSubject[java]1. package cn.lynn.observer;2.3. public class DongHuCitizen extends Citizen {4.5. public DongHuCitizen(Policeman police) {6. setPolices();7. register(police);8. }9.10. @Override11. public void notify(String action) {12. setAction(action);13. for (int i = 0; i < polices.size(); i++) {14. Policeman police = polices.get(i);15. police.setOut(this);16. }17. }18.19. }[java]1. package cn.lynn.observer;2.3. public class NanHuCitizen extends Citizen {4.5. public NanHuCitizen(Policeman police) {6. setPolices();7. register(police);8. }9.10. @Override11. public void notify(String action) {12. setAction(action);13. for (int i = 0; i < polices.size(); i++) {14. Policeman police = polices.get(i);15. police.setOut(this);16. }17. }18.19. }ConcreteObserver[java]1. package cn.lynn.observer;2.3. public class DongHuPoliceman implements Policeman {4.5. @Override6. public void setOut(Citizen citizen) {7. String action = citizen.getAction();8. if(action.equals("normal")) {9. System.out.println("⾏为⼀切正常");10. } else if(action.equals("unnormal")) {11. System.out.println("有偷窃⾏为，东湖警察出动！");12. }13. }14.15. }[java]1. package cn.lynn.observer;2.3. public class NanHuPoliceman implements Policeman {4.5. @Override6. public void setOut(Citizen citizen) {7. String action = citizen.getAction();8. if(action.equals("normal")) {9. System.out.println("⾏为⼀切正常");10. } else if(action.equals("unnormal")) {11. System.out.println("有抢劫⾏为，南湖警察出动！");12. }13. }14.15. }Client[java]1. package cn.lynn.observer;2.3. public class Client {4.5. public static void main(String[] args) {6. Policeman dhPolice = new DongHuPoliceman();7. Policeman nhPolice = new NanHuPoliceman();8.9. Citizen citizen = new DongHuCitizen(dhPolice);10. citizen.notify("normal");11. citizen.notify("unnormal");12.13. citizen = new NanHuCitizen(nhPolice);14. citizen.notify("normal");15. citizen.notify("unnormal");16. }17. }Result[java]1. ⾏为⼀切正常2. 有偷窃⾏为，东湖警察出动！3. ⾏为⼀切正常4. 有抢劫⾏为，南湖警察出动！。