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种设计模式记忆 口诀

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种设计模式

Java开发中的23种设计模式

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

23种设计模式记忆口诀

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种设计模式记忆口诀

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

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

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

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

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

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

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

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

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

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

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

面向对象设计的23个设计模式详解

面向对象设计的23个设计模式详解

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

23种设计模式资料

23种设计模式资料

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

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

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

其实还有两类:并发型模式和线程池模式。

用一个图片来整体描述一下:二、设计模式的六大原则1、开闭原则(Open Close Principle)开闭原则就是说对扩展开放,对修改关闭。

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

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

想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

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

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

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

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

实现“开-闭”原则的关键步骤就是抽象化。

而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。

—— From Baidu 百科3、依赖倒转原则(Dependence Inversion Principle)这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。

4、接口隔离原则(Interface Segregation Principle)这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。

23种设计模式记忆口诀

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种设计模式 详解

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

23种设计模式整理

23种设计模式整理
不易得到时,也可以采用建造者模式封装该对象的创建过程。该种场景, 只能是一个补偿方法,因为一个对象不容易获得,而在设计阶段竟然没有发觉, 而要通过创建者模式柔化创建过程,本身已经违反设计最初目标。
public interface Builder { void buildPartA(); void buildPartB(); void buildPartC(); Product getResult(); }
8.
}
9. }
10.
11. interface IFactory {
12. public IProduct createProduct();
13. }
14.
15. class Factory implements IFactory {
16. public IProduct createProduct() {
22. }
23. class Factory implements IFactory{
24. public IProduct1 createProduct1() {
25.
return new Product1();
26. }
27. public IProduct2 createProduct2() {
建造者模式的使用场景 1)相同的方法,不同的执行顺序,产生不同的事件结果时,可以采用建造者模式。 2)多个部件或零件,都可以装配到一个对象中,但产生的运行结果又不相同时,可以使用该模式 3)产品类非常复杂,或产品类中的调用顺序不同产生了不同的效能,此使用建造者模式很合适 4)在对象创建过程中会使用到系统中的一些其它对象,这些对象在产品对象的创建过程中
28.
return new Product2();

设计模式-23种设计模式整体介绍及应用场景、七大设计原则总结

设计模式-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种设计模式总结

23种设计模式总结设计模式是一种解决反复出现的设计问题的方案,它们被广泛应用于软件设计和架构中。

在这里,我们列举了23种常用的设计模式,分别属于创建型、结构型和行为型模式。

一、创建型模式1. 工厂方法模式(Factory Method Pattern)定义一个创建对象的接口,但让子类决定实例化哪个类。

工厂方法模式是让类来进行对象的创建,而不是由你的代码直接new 出来。

2. 抽象工厂模式(Abstract Factory Pattern)提供一个接口,用于创建一系列相关或相互依赖的对象。

3. 单例模式(Singleton Pattern)确保一个类只有一个实例,并提供一个全局访问点。

4. 建造者模式(Builder Pattern)将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

5. 原型模式(Prototype Pattern)用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。

二、结构型模式6. 适配器模式(Adapter Pattern)将一个类的接口转换成客户希望的另外一个接口。

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

7. 桥接模式(Bridge Pattern)将抽象部分与它的实现部分分离,使它们都可以独立地变化。

8. 组合模式(Composite Pattern)将对象组合成树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。

9. 装饰器模式(Decorator Pattern)动态地给一个对象添加一些额外的职责,就增加功能来说,装饰器比生成子类更为灵活。

10. 外观模式(Facade Pattern)为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,使得这一子系统更加容易使用。

11. 享元模式(Flyweight Pattern)运用共享技术有效地支持大量细粒度的对象。

23种设计模式知识总结

23种设计模式知识总结

设计模式目 录一、 行为模式 (2)1、 命令模式 (2)2、 观察者模式 (2)3、 策略模式 (3)4、 责任链模式 (4)5、 迭代器模式 (5)6、 中介者模式 (5)7、 状态模式 (6)8、 模板方法模式 (7)9、 访问者模式 (7)10、 备忘录模式 (8)11、 解释器模式 (9)二、 结构型模式 (9)12、 适配器模式 (9)13、 桥接模式 (10)14、 组合模式 (11)15、 装饰模式 (11)16、 外观模式 (12)17、 代理模式 (12)18、 享元模式 (13)三、 创建型模式 (14)19、 工厂方法模式 (14)20、 抽象工厂模式 (14)21、 建造者模式 (15)22、 原型模式 (16)23、 单件模式 (17)一、 行为模式1、命令模式将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。

自己的理解:将命令的发起者与命令的执行者分离,实现他们之间的松耦合关系。

这样可以方便地添加和实现各种不同命令。

参与者:mand声明执行操作的接口。

2.ConcreteCommand将一个接收者对象绑定于一个动作。

调用接收者相应的操作,以实现Execute。

3.Invoker要求该命令执行这个请求。

4.Receiver知道如何实现与执行一个请求相关的操作。

任何类都可能作为一个接收者。

2、观察者模式定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

自己的理解:当一个主题发生变化后,多个观察者需要作出反应时,可以将这些观察者在其观察的主题处进行注册。

当该主题变化后,就通知所有在它这里注册的观察者。

主题的更新与观察者的反应分离,这样实现主题和观察者之间的松耦合关系。

参与者:1.Subject(目标)目标知道它的观察者。

可以有任意多个观察者观察同一个目标。

设计模式分为三大类23种(单例模式)

设计模式分为三大类23种(单例模式)

设计模式分为三⼤类23种(单例模式)1) 创建型模式:单例模式、抽象⼯⼚模式、原型模式、建造者模式、⼯⼚模式。

2) 结构型模式:适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

3) ⾏为型模式:模版⽅法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式)。

单例模式:定义: 所谓类的单例设计模式,就是采取⼀定的⽅法保证在整个的软件系统中,对某个类只能存在⼀个对象实例,并且该类只提供⼀个取得其对象实例的⽅法(静态⽅法)单例模式有⼋种⽅式:1) 饿汉式(静态常量)2) 饿汉式(静态代码块)3) 懒汉式(线程不安全)4) 懒汉式(线程安全,同步⽅法)5) 懒汉式(线程安全,同步代码块)6) 双重检查7) 静态内部类8) 枚举1. 饿汉式(静态常量)步骤如下:1) 构造器私有化 (防⽌new )2) 类的内部创建对象3) 向外暴露⼀个静态的公共⽅法。

getInstance4) 代码实现优缺点说明:1) 优点:这种写法⽐较简单,就是在类装载的时候就完成实例化。

避免了线程同步问题。

2) 缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。

如果从始⾄终从未使⽤过这个实例,则会造成内存的浪费3) 这种⽅式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,在单例模式中⼤多数都是调⽤getInstance⽅法,但是导致类装载的原因有很多种,因此不能确定有其他的⽅式(或者其他的静态⽅法)导致类装载,这时候初始化instance就没有达到lazy loading的效果4) 结论:这种单例模式可⽤,可能造成内存浪费 2 饿汉式(静态代码块)应⽤实例优缺点说明:1) 这种⽅式和上⾯的⽅式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执⾏静态代码块中的代码,初始化类的实例。

java23种设计模式详解

java23种设计模式详解

java23种设计模式详解跟晓明⼀起学java之java设计模式本⽂参考了:/tiancai/blog/224624⼀、设计模式的分类1、创建型模式有五种:⼯⼚⽅法模式,抽象⼯⼚模式,单例模式,创建者模式,原型模式。

2、结构型模式有七种:适配器模式,装饰器模式,代理模式,外观模式,桥接模式,组合模式,享元模式。

3、⾏为型模式有⼗⼀种:策略模式,模板⽅法模式,责任链模式,命令模式,迭代⼦模式,观察者模式,备忘录模式,状态模式,中介者模式,访问者模式,解释器模式。

⼆、设计模式的基本原则待完成三、设计模式详解1、创建型模式⾸先介绍⼀下⼀下简单⼯⼚模式,简单⼯⼚模式不属于23种设计模式之⼀。

简单⼯⼚模式(1)单⽅法简单⼯⼚模式就是创建⼀个⼯⼚类,对实现了同⼀个接⼝的实现类进⾏实例化。

<1> 关系图1><2>⾸次创建接⼝:2>public interface ISend { public void send();}<3> 然后创建实现类:3>/** * 邮件发送实现类 * @author Administrator * */public class MailSend implements ISend{@Override public void send() { System.out.println('邮件发送信息!'); }}/** *短信发送实现类 * @author Administrator * */public class MessageSend implements ISend{ @Override public void send() { System.out.println('短信发送信息!'); }}<4>创建简单⼯⼚类:4>/** * 简单⼯程类 * @author Administrator * */public class SigleMethodFactory { public ISend produce(String type){ if('mail'.equals(type)){ return new MailSend(); }elseif('message'.equals(type)){ return new MessageSend(); } return null; }}<5>测试5>public class SimpleFactoryTest { public static void main(String[] args){ ISend send = new SigleMethodFactory().produce('mail'); send.send(); }}输出:邮件发送信息!(2)多⽅法是对单⽅法简单⼯⼚⽅法模式的改进,如果但⽅法传⼊的字符串不正确,则不能创建出对象,⽽多个⽅法的简单⼯⼚模式,是提供多个⼯⼚⽅法来创建不同的对象。

  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 来实现。最优的办法是如通用代码那样写。
相关文档
最新文档