23种设计模式知识要点

合集下载

常见的二十三种设计模式

常见的二十三种设计模式

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

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

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

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

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

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

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

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

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

抽象⼯⼚模式(Abstract Factory Pattern)使⽤该功能类的功能类,利⽤抽象⼯⼚去创建该功能类的实例。

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

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

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

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

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

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

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

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

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

23种设计模式及应用

23种设计模式及应用

23种设计模式及应用设计模式是指在软件设计过程中,针对常见问题的解决方案的经验总结。

它们提供了解决特定或常见问题的可重用方案,使得软件设计更加灵活、可扩展和可维护。

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

- 简单工厂模式:通过一个共同的接口创建不同的对象实例。

- 工厂方法模式:定义一个创建对象的接口,由子类决定具体创建哪个对象。

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

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

2. 结构型模式:- 适配器模式:将一个类的接口转换为客户端所期待的另一种接口。

- 桥接模式:将抽象部分与它的实现部分分离,使它们可以独立变化。

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

- 装饰器模式:动态地给对象添加额外的功能,避免继承带来的类膨胀问题。

- 外观模式:为子系统中一组接口提供一个一致的界面。

3. 行为型模式:- 策略模式:定义一系列算法,将它们封装起来,并使它们可以相互替换。

- 观察者模式:定义对象之间的依赖关系,当对象状态改变时自动通知依赖方。

- 模板方法模式:定义一个操作中的算法骨架,将一些步骤延迟到子类中实现。

- 命令模式:将一个请求封装成一个对象,从而使您可以用不同的请求参数化客户端对象。

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

4. J2EE模式:- MVC模式:将应用程序划分为三个核心组件:模型、视图和控制器。

- 业务代表模式:将对业务对象的访问和业务逻辑从表示层分离出来。

- 数据访问对象模式:用于将业务逻辑和数据访问逻辑分离。

- 前端控制器模式:通过一个单一的入口点来处理应用程序的所有请求。

- 传输对象模式:用于在客户端和服务器之间传输数据。

5. 并发模式:- 线程池模式:创建一组预先初始化的线程对象来处理任务。

23种设计模式的详解

23种设计模式的详解

23种Java设计模式设计模式分两类:创建型模式、行为型模式。

一、创建型模式 :1、FACTORY—追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西,虽然口味有所不同,但不管你带MM去麦当劳或肯德基,只管向服务员说“来四个鸡翅”就行了。

麦当劳和肯德基就是生产鸡翅的Factory1、工厂模式:客户类和工厂类分开。

消费者任何时候需要某种产品,只需向工厂请求即可。

消费者无须修改就可以接纳新产品。

缺点是当产品修改时,工厂类也要做相应的修改。

如:如何创建及如何向客户端提供。

2、BUILDER—MM最爱听的就是“我爱你”这句话了,见到不同地方的MM,要能够用她们的方言跟她说这句话哦,我有一个多种语言翻译机,上面每种语言都有一个按键,见到MM我只要按对应的键,它就能够用相应的语言说出“我爱你”这句话了,国外的MM也可以轻松搞掂,这就是我的“我爱你” builder。

(这一定比美军在伊拉克用的翻译机好卖)2、建造模式:将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。

建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。

建造模式可以强制实行一种分步骤进行的建造过程。

3、FACTORY METHOD—请MM去麦当劳吃汉堡,不同的MM有不同的口味,要每个都记住是一件烦人的事情,我一般采用Factory Method模式,带着MM到服务员那儿,说“要一个汉堡”,具体要什么样的汉堡呢,让MM直接跟服务员说就行了。

3、工厂方法模式:核心工厂类不再负责所有产品的创建,而是将具体创建的工作交给子类去做,成为一个抽象工厂角色,仅负责给出具体工厂类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。

4、PROTOTYPE—跟MM用QQ聊天,一定要说些深情的话语了,我搜集了好多肉麻的情话,需要时只要copy出来放到QQ里面就行了,这就是我的情话prototype了。

23种设计模式

23种设计模式
之间的访问。
结构图
角色与理解
核心代码
享元模式(FlyweightPattern)(实现对象的复用)
定义
结构图
将系统中细粒度的相同的或者
相似的对象以共享的方式存放
在享元池中供客户端使用。
01
02
角色与理解
03
04
核心代码
代理模式(ProxyPattern)(控制对象的访问)
2014 2015 2016 2017
工厂模式 (Fa ctor yPa t t er n )
简单工厂模式 (SimpleFactor
yPattern)
工厂方法模式 (Factor yM eth
odPattern)
抽象工厂模式 (AbstractFact
or yPa tter n )
简单工厂模式(SimpleFactor yPattern)
04 核心代 码
建造者模式(BuilderPattern)(复杂对象的构建)
定义
结构图
将一个复杂对象的构建与它
的表示分离,使同样的构建 过程可以创建不同的表示
01
02
角色与理解
03
04
核心代码
结构型 (StructuralPatter ns)
适配器模式(AdapterPattern)(不兼容结构的协调)
定义
通过一个代理对象或者占位符来控制对原对象的访问。
结构图
角色与理解
核心代码
行为型 (BehavioralPatte rns)
责任链模式 (ChainOfResponsibilityPatter n)(请求的链式处理)
定义 将请求发送者和请求接受者解
耦,让请求的接受者形成链式操 作,所有人都能够接受接受到请 求,直到有人处理请求。

面向对象23种设计模式

面向对象23种设计模式

面向对象23种设计模式面向对象23种设计模式在面向对象的编程中,设计模式是一种解决问题的通用方案。

设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性,并提高代码的可维护性和可重用性。

本文将介绍23种面向对象的设计模式。

1. 工厂方法模式工厂方法模式是一种创建型设计模式,它定义了一个用于创建对象的接口,但是让子类决定实例化哪个类。

在工厂方法模式中,客户端不需要知道具体的创建逻辑,只需要知道工厂类中定义的接口即可。

2. 抽象工厂模式抽象工厂模式是一种创建型设计模式,它提供了一个接口,用于创建相关或依赖对象的家族,而不需要指定它们的具体类。

在抽象工厂模式中,客户端不需要知道具体的创建逻辑,只需要知道工厂类中定义的接口即可。

3. 单例模式单例模式是一种创建型设计模式,它保证一个类只有一个实例,并提供一个访问该实例的全局点。

4. 原型模式原型模式是一种创建型设计模式,它允许复制或克隆一个现有的对象,而不必知道其具体实现。

5. 建造者模式建造者模式是一种创建型设计模式,它允许逐步创建复杂的对象,而不必知道其内部实现细节。

6. 适配器模式适配器模式是一种结构型设计模式,它将一个或多个不兼容的类或接口转换为客户端所需的接口。

7. 桥接模式桥接模式是一种结构型设计模式,它将抽象部分与其实现部分分离开来,以便独立地进行修改。

8. 组合模式组合模式是一种结构型设计模式,它将一组对象作为单个对象处理,以便客户端可以以相同的方式处理单个对象和组合对象。

9. 装饰器模式装饰器模式是一种结构型设计模式,它允许向现有对象添加额外的功能,同时不改变其现有的结构。

10. 外观模式外观模式是一种结构型设计模式,它为一组复杂的子系统提供了一个统一的接口,以便于客户端使用。

11. 享元模式享元模式是一种结构型设计模式,它利用共享技术来最小化内存使用,以及提高应用程序的性能。

12. 代理模式代理模式是一种结构型设计模式,它提供了一个代理对象,使得客户端可以通过代理对象间接地访问实际对象。

23种设计模式简要说明

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种设计模式记忆口诀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种设计模式,并且可以在以后的工作中灵活地运用它们。

Java开发中的23种设计模式

1、工厂模式:客户类和工厂类分开。

消费者任何时候需要某种产品,只需向工厂请求即可。

消费者无须修改就可以接纳新产品。

缺点是当产品修改时,工厂类也要做相应的修改。

如:如何创建及如何向客户端提供。

2、建造模式:将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。

建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。

建造模式可以强制实行一种分步骤进行的建造过程。

3、工厂方法模式:核心工厂类不再负责所有产品的创建,而是将具体创建的工作交给子类去做,成为一个抽象工厂角色,仅负责给出具体工厂类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。

4、原始模型模式:通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。

原始模型模式允许动态的增加或减少产品类,产品类不需要非得有任何事先确定的等级结构,原始模型模式适用于任何的等级结构。

缺点是每一个类都必须配备一个克隆方法。

5、单例模式:单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例模式。

单例模式只应在有真正的“单一实例”的需求时才可使用。

6、适配器(变压器)模式:把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。

适配类可以根据参数返还一个合适的实例给客户端。

7、桥梁模式:将抽象化与实现化脱耦,使得二者可以独立的变化,也就是说将他们之间的强关联变成弱关联,也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系,从而使两者可以独立的变化。

8、合成模式:合成模式将对象组织到树结构中,可以用来描述整体与部分的关系。

合成模式就是一个处理对象的树结构的模式。

合成模式把部分与整体的关系用树结构表示出来。

合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。

23种设计模式记忆口诀

23种设计模式记忆口诀设计模式是软件开发中常见的解决方案模板,它们能够解决许多常见的设计问题。

为了帮助记忆23种设计模式,可以使用下面这个口诀来记忆:Creational Patterns(创建型模式):1. Singleton(单例模式):一个类能产生一个实例,全局访问。

2. Builder(建造者模式):分步骤创建复杂对象,易拓展。

3. Factory Method(工厂方法模式):子类决定实例化哪个对象。

4. Abstract Factory(抽象工厂模式):创建一组相关对象,不依赖具体类。

5. Prototype(原型模式):通过复制现有对象来创建新对象。

Structural Patterns(结构型模式):6. Adapter(适配器模式):将类的接口转换为客户端希望的接口。

7. Bridge(桥接模式):将抽象部分与实际部分分离。

将对象组合成树形结构来表示部分整体的层次结构。

9. Decorator(装饰器模式):动态地给对象添加功能。

10. Facade(外观模式):提供一个统一的接口,简化客户端使用。

11. Flyweight(享元模式):共享细粒度对象,减少内存使用。

12. Proxy(代理模式):控制对其他对象的访问。

Behavioral Patterns(行为型模式):13. Chain Of Responsibility(责任链模式):将请求的发送者和接收者解耦,多个对象都可能处理请求。

将请求封装成对象,可以用参数化方式处理。

15. Iterator(迭代器模式):提供一种遍历集合的统一接口。

16. Mediator(中介者模式):将多个对象之间的复杂关系解耦。

17. Memento(备忘录模式):将对象的状态保存起来,以后可以恢复。

18. Observer(观察者模式):当一个对象改变状态时,依赖它的对象都会收到通知。

19. State(状态模式):对象的行为随状态的改变而改变。

系统架构设计师23种设计模式记忆口诀

系统架构设计师23种设计模式记忆口诀设计模式分为三种类型:创建型设计模式(4种:工厂模式(工厂模式、抽象工厂模式)、单例模式、原型模式、建造者模式)主要用户创建对象;创建型:创建模式创对象。

工厂模式要抽象;单例只有一个类;拷贝原型创对象;建造复杂的对象。

解释:创建模式主要用于创建对象。

工厂模式根据业务需要分为简单工厂模式、工厂方法模式和抽象工厂模式;原型模式用于创建重复的对象,通过拷贝这些原型创建新的对象;建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。

------------------------------------------------------------------------------- 结构型设计模式(8种:代理模式、外观模式、装饰器模式、享元模式、组合模式、适配器模式、桥接模式、过滤器)主要关注类和对象的组合;结构型:结构组合类对象。

代理外观装饰器;享元组合适配器;桥接不能过滤器。

代理对象访问者;外观一致的接口;装饰动态添职责;享元共享搞对象。

组合对象像棵树;适配接口能兼容;桥接抽象与实现;不同标准来过滤。

解释:结构型设计模式主要关注类和对象的组合。

主要有代理模式、外观模式、装饰器模式、享元模式、组合模式、适配器模式、桥接模式不能继承,过滤器模式。

代理模式为其他对象提供一种代理以控制对这个对象的访问;外观模式通过为多个复杂的子系统提供一个一致的接口,而使这些子系统更加容易被访问的模式,这是典型的”迪米特原则“;装饰器模式动态地给一个对象添加一些额外的职责;享元模式运用共享技术来有效地支持大量细粒度对象的复用;组合模式将对象组合成树形结构以表示"部分-整体"的层次结构;适配器模式将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作;桥接模式将抽象部分与实现部分分离,使它们都可以独立的变化;过滤器模式允许开发人员使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把它们连接起来行为型设计模式(11种:模板模式、策略模式、迭代器模式、中介模式、备忘录模式、解释器模式、观察者模式、访问者模式、状态模式、责任链模式、命令模式)主要关注对象间通信的问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

多个工厂类: 每个人种(具体的产品类)都对应了一个创建者,每个创建者独立负责创建对应的 产品对象,非常符合单一职责原则
代替单例模式: 单例模式的核心要求就是在内存中只有一个对象,通过工厂方法模式也可以只在内 存中生产一个对象
延迟初始化: ProductFactory 负责产品类对象的创建工作,并且通过 prMap 变量产生一个缓 存,对需要再次被重用的对象保留
使用场景:jdbc 连接数据库,硬件访问,降低对象的产生和销毁
3.抽象工厂模式(Abstract Factory Pattern)
定义:Provide an interface for creating families of related or dependent objects without specifying their concrete classes.(为创建一组相关或相互依赖的对象提供 一个接口,而且无须指定它们的具体类。) 抽象工厂模式通用类图:
private static final Singleton singleton = new Singleton(); //限制产生多个对象
private Singleton(){ } //通过该方法获得实例对象 public static Singleton getSingleton(){
return singleton; } //类中其他方法,尽量是 static publห้องสมุดไป่ตู้c static void doSomething(){ } }
1.单例模式(Singleton Pattern)
定义:Ensure a class has only one instance, and provide a global point of access to it.(确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实 例。)
通用代码:(是线程安全的) public class Singleton {
线程不安全实例: public class Singleton {
private static Singleton singleton = null; //限制产生多个对象 private Singleton(){ } //通过该方法获得实例对象 public static Singleton getSingleton(){
4.模板方法模式(Template Method Pattern)
定义:Define the skeleton of an algorithm in an operation,deferring some steps to subclasses.Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.(定义一个操作中的算法的框 架,而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义 该算法的某些特定步骤。)
Product product=null; try {
product = (Product)Class.forName(c.getName()).newInstance();
} catch (Exception e) { //异常处理
} return (T)product; } }
简单工厂模式: 一个模块仅需要一个工厂类,没有必要把它产生出来,使用静态的方法
2.工厂模式
定义:Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses. (定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类 的实例化延迟到其子类。)
抽象工厂模式通用源码类图:
抽象工厂类代码: public abstract class AbstractCreator {
//创建 A 产品家族 public abstract AbstractProductA createProductA(); //创建 B 产品家族 public abstract AbstractProductB createProductB(); } 使用场景: 一个对象族(或是一组没有任何关系的对象)都有相同的约束。 涉及不同操作系统的时候,都可以考虑使用抽象工厂模式
Product 为抽象产品类负责定义产品的共性,实现对事物最抽象的定义; Creator 为抽象创建类,也就是抽象工厂,具体如何创建产品类是由具体的实现工 厂 ConcreteCreator 完成的。 具体工厂类代码: public class ConcreteCreator extends Creator { public <T extends Product> T createProduct(Class<T> c){
使用场景: ● 要求生成唯一序列号的环境; ● 在整个项目中需要一个共享访问点或共享数据,例如一个 Web 页面上的计数 器,可以不用把每次刷新都记录到数据库中,使用单例模式保持计数器的值,并确 保是线程安全的; ● 创建一个对象需要消耗的资源过多,如要访问 IO 和数据库等资源; ● 需要定义大量的静态常量和静态方法(如工具类)的环境,可以采用单例模式 (当然,也可以直接声明为 static 的方式)。
if(singleton == null){ singleton = new Singleton();
} }
} return singleton;
解决办法: 在 getSingleton 方法前加 synchronized 关键字,也可以在 getSingleton 方法内增 加 synchronized 来实现。最优的办法是如通用代码那样写。
相关文档
最新文档