23种设计模式

常见的⼆⼗三种设计模式按照⽬的来分，设计模式可以分为创建型模式、结构型模式和⾏为型模式。

创建型模式⽤来处理对象的创建过程；结构型模式⽤来处理类或者对象的组合；⾏为型模式⽤来对类或对象怎样交互和怎样分配职责进⾏描述。

创建型模式⽤来处理对象的创建过程，共以下五种：单例模式（Singleton Pattern）能避免同⼀对象被反复实例化。

⽐如说，访问数据库的连接对象就⽐普通对象实例化的时间要长;WCF中，维护服务器端远程对象的创建等，这类情况，很有必要⽤单例模式进⾏处理对象的实例化。

简单⼯⼚模式通过在⼯⼚类中进⾏判断，然后创建需要的功能类。

优点：不必使⽤具体的功能类去创建该类的实例。

缺点：新增⼀个功能类就需要在⼯⼚类中增加⼀个判断。

⼯⼚⽅法模式（Factory Method Pattern）把简单⼯⼚模式中的⼯⼚类，做了进⼀步的抽象为接⼝或抽象类，给各个功能创建⼀个对应的⼯⼚类，然后在这个⼯⼚类⾥⾯去创建对应的实例。

缺点：当新增⼀个功能类，就需要创建对于的⼯⼚类，相⽐简单⼯⼚模式，免去了判断创建那个具体实例，但会创建过多的类，还不如策略模式。

抽象⼯⼚模式（Abstract Factory Pattern）使⽤该功能类的功能类，利⽤抽象⼯⼚去创建该功能类的实例。

这样的好处在于尽可能的避免去创建功能的实例。

更⽜逼的做法就是使⽤反射去创建这个功能类的实例，在调⽤端就⼀点都不需要知道要去实例化那个具体的功能类。

这当然不是抽象⼯⼚模式独有的。

建造者模式（Builder Pattern）每个对象都具备⾃⼰的功能，但是，它们的创建⽅式却是⼀样的。

这个时候就需要中间这个建造者类来负责功能对象实例的创建。

在调⽤端只需调⽤特定的⽅法即可。

这个和策略模式有点类似。

原型模式（Prototype Pattern）创建好了⼀个实例，然后⽤这个实例，通过克隆⽅式创建另⼀个同类型的实例，⽽不必关⼼这个新实例是如何创建的。

原型模式使⽤时需要注意浅拷贝与深拷贝的问题。

一．创建型模式1．单件模式意图保证一个类仅有一个实例，并提供一个访问它的全局访问点。

适用性当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

2．抽象工厂意图提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

适用性一个系统要独立于它的产品的创建、组合和表示时。

一个系统要由多个产品系列中的一个来配置时。

当你要强调一系列相关的产品对象的设计以便进行联合使用时。

当你提供一个产品类库，而只想显示它们的接口而不是实现时。

3．建造者模式意图将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用性当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

当构造过程必须允许被构造的对象有不同的表示时。

4．工厂方法模式意图定义一个用于创建对象的接口，让子类决定实例化哪一个类。

Factory Method 使一个类的实例化延迟到其子类。

适用性当一个类不知道它所必须创建的对象的类的时候。

当一个类希望由它的子类来指定它所创建的对象的时候。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

5．原型模式意图用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

适用性当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者为了避免创建一个与产品类层次平行的工厂类层次时；或者当一个类的实例只能有几个不同状态组合中的一种时。

建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

二．结构型模式6．适配器模式意图将一个类的接口转换成客户希望的另外一个接口。

Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适用性你想使用一个已经存在的类，而它的接口不符合你的需求。

你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。

23种设计模式记忆口诀1.单例模式：独一无二，最重要。

2.工厂模式：制造者，无需说。

3.抽象工厂：一族产品，同根源。

4.建造者模式：一步一步，建造家。

5.原型模式：克隆专家，快捷法。

6.适配器模式：转换者，聪明智。

7.桥接模式：结构优化，灵活性。

8.装饰模式：装饰者，美化家。

9.组合模式：树形结构，组合家。

10.外观模式：微缩封装，简洁家。

11.享元模式：享元工厂，节省家。

12.代理模式：替身幕后，保护家。

13.模板方法：算法继承，不变家。

14.策略模式：行为封装，灵活家。

15.命令模式：命令者，有权家。

16.职责链模式：可扩展，级别性。

17.状态模式：状态管理，干净家。

18.观察者模式：被观察，自主家。

19.中介者模式：中介者，沟通家。

20.迭代器模式：循环选择，简化家。

21.访问者模式：动态添加，扩展家。

22.备忘录模式：状态备份，还原家。

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块钱一份,你要不要)原始模型模式:通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。

新版设计模式手册一．创建型模式1．单件模式意图保证一个类仅有一个实例，并提供一个访问它的全局访问点。

适用性当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

2．抽象工厂意图提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

适用性一个系统要独立于它的产品的创建、组合和表示时。

一个系统要由多个产品系列中的一个来配置时。

当你要强调一系列相关的产品对象的设计以便进行联合使用时。

当你提供一个产品类库，而只想显示它们的接口而不是实现时。

3．建造者模式意图将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用性当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

当构造过程必须允许被构造的对象有不同的表示时。

4．工厂方法模式意图定义一个用于创建对象的接口，让子类决定实例化哪一个类。

Factory Method 使一个类的实例化延迟到其子类。

适用性当一个类不知道它所必须创建的对象的类的时候。

当一个类希望由它的子类来指定它所创建的对象的时候。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

5．原型模式意图用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

适用性当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者为了避免创建一个与产品类层次平行的工厂类层次时；或者当一个类的实例只能有几个不同状态组合中的一种时。

建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

二．结构型模式6．适配器模式意图将一个类的接口转换成客户希望的另外一个接口。

Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适用性你想使用一个已经存在的类，而它的接口不符合你的需求。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Abstract Factory：一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

Adapter：将一个类的接口转换成客户希望的另外一个接口。

A d a p t e r模式使得原本由于接口不兼容而不能工作的那些类可以工作。

Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

Builder：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

Chain of Responsibility：为解除请求的者和接收者之间耦合，而使多个对象都有机会处理这个请求。

将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

Command：将一个请求装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。

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

它使得客户对单个对象和复合对象的使用具有一致性。

Decorator：动态地给一个对象一些额外的职责。

就扩展功能而言，它比生成子类更为灵活。

Facade：为子系统中的一组接口一个一致的界面， F a c a d e模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

Factory Method：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。

Factory Method使一个类的实例化延迟到其子类。

Flyweight：运用共享技术有效地支持量细粒度的对象。

Interpreter：给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。

Iterator：一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

Mediator：用一个中介对象来装一系列的对象交互。

中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

Memento：在不破坏装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

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

23种设计模式（Design Patterns）设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

一、总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

还用两类模式：并发型模式和线程池模式。

二、设计模式六大原则:总原则：开闭原则开闭原则就是说对扩展开放，对修改关闭。

在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。

所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使用接口和抽象类等。

1、单一职责原则不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

2、里氏替换原则（Liskov Substitution Principle）里氏代换原则(Liskov Substitution Principle LSP)是面向对象设计的基本原则之一。

里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。

LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

里氏代换原则是对“开-闭”原则的补充。

设计模式概述（23种设计模式⽬录）设计模式概述：总体来说基本的23种设计模式分为三⼤类创建型模式（5种）：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。

结构型模式（7种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

⾏为型模式（11种）：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

⾯向对象编程（杂）所有编程初学者都会有这样的问题，就是碰到问题就直觉地⽤计算机能够理解的逻辑来描述和表达待解决问题及具体的求解过程，这其实是⽤计算机的⽅式去思考，⽐如计算器这个程序，先要求输⼊两个数和运算符号，然后根据运算符号判断如何运算，得到结果，这本⾝没有错，但这样的思维却使得我们的程序只为满⾜实现当前的需求，程序不容易维护，不容易扩展，更不容易复⽤。

从⽽达不到⾼质量代码的要求。

如何才能容易维护，容易扩展，⼜容易复⽤呢？例：活字印刷术：改：只需改相应字（可维护），创造出这些字⽤完以后就并⾮⽆⽤，完全可以在后来的印刷中重复使⽤（可复⽤），若要加字，只需另刻字即可（可扩展），同时实现了字体的横向摆放或纵向摆放问题（灵活性好），活字印刷是思想的成功，⾯向对象（将每个字当做⼀个对象来处理）的胜利。

⾯向对象编程设计思想：通过封装，继承，多态把程序的耦合度降低。

复制VS复⽤：编程有⼀原则，就是⽤尽可能的办法去避免重复，以计算器为例，我们可以让计算和显⽰分开（哪些与控制台相关，哪些与计算相关）（实际就是让业务逻辑和界⾯逻辑分开，让他们之间的耦合度下降，只有分离开，才可以容易达到维护和扩展。

）⾯向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。

例：打⼀折和打九折只是形式的不同，抽象分析出来，所有的打折算法都是⼀样的，所以打折算法应该是⼀个类。

23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。

这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。

目前，常用的设计模式有23种。

下面，我们来详细介绍一下这23种设计模式。

1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。

在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。

2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。

它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。

3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。

它可以生成一系列相关或相互依赖的对象实例。

具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。

4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。

它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。

5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。

一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。

6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。

具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。

7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。

具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。

8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。

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）：定义一个算法的骨架，由子类实现具体步骤。

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种设计模式范文设计模式是用来解决软件设计中的常见问题的经验总结和最佳实践。

这些模式抽象了实际应用中的问题，并提供了相应的解决方案。

本文将介绍23种经典的设计模式，并简要描述它们的用途和示例。

1.创建型模式-单例模式：保证一个类只有一个实例，并提供一个全局访问点。

-工厂模式：将对象的创建委托给工厂类，隐藏具体实现细节。

-抽象工厂模式：提供一个用于创建一系列相关或相互依赖对象的接口。

-建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

-原型模式：通过复制已有对象来创建新对象，避免了直接创建对象的开销。

2.结构型模式-适配器模式：将一个类的接口转换成客户希望的另一个接口。

-桥接模式：将抽象部分与其实现部分相分离，使它们可以独立变化。

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

-装饰者模式：动态地给对象添加额外的职责，同时又不改变其结构。

-外观模式：为复杂子系统提供一个简化的接口。

-享元模式：通过共享对象来实现对大量细粒度对象的有效共享。

3.行为型模式-模板方法模式：定义一个操作中的算法框架，将一些步骤的具体实现延迟到子类中。

-命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化。

-迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。

-观察者模式：定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。

-中介者模式：用一个中介对象封装一系列对象的交互，使各对象不需要显示地相互引用。

-备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

-解释器模式：给定一个语言，定义它的语法的一种表示，并定义一个解释器来解释该语言中的句子。

-状态模式：允许对象在其内部状态改变时改变它的行为。

-空对象模式：使用一个空对象来代替NULL对象的检查。