解释器模式应用场景,图解几种常见的软件架构模式
解释器模式应用场景,图解几种常见的软件架构模式详细介绍
本文目录一览： 设计模式[22]-解释器模式-Interpreter Pattern
解释器模式(Interpreter Pattern)模式是行为型(Behavioral)设计模式，定义语言的文法，并且建立一个解释器来解释该语言的句子。
在实际应用中，很少有机会碰到去构造一个语言的文法；学习这个设计模式，也许是个投入产出比较小的行为。
如上图所示，解释器模式一共有四种角色：
(1) AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。
(2) TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。
(3) NonterminalExpression（非终结符表达式）：为文法中的非终结符号实现解释操作。
(4) Context(上下文类）：用于存储解释器之外的一些全局信息，临时存储需要解释的语句。
举例： a + b = c ，变量a、b是终结符表达式， + (加法)是非终结符表达式；同样，加减乘除与或非等，都是非终结符表达式。
下面做个整数加减乘除运算的例子。
类图如下
1. Context 上下文类
2.Expression 抽象表达式
3. Constant，常量表达式
4. Variable，变量表达式
5.Add，加法表达式
6.Subtract 减法表达式
7.Multiply 乘法表达式
8. Division 除法表达式
9. StateMain 演示类
结果输出
解释器模式为自定义语言提供了一种方式，它用于组织一套语法规则，并通过语法规则来解释语言中的句子。应用开发中，没有什么机会能够使用到解释器模式，可能正则表达式、XML解析之类场景可以用到解释器模式。
（完）
几种常见的软件架构是什么？
10种常见软件架构模式
是否想知道大型企业级系统是怎么设计的？在软件主体开发之前，我们必须选择一个合适的架构来提供所需的功能和质量特征。所以在应用于设计之前，我们应该了解不同的架构。
什么是架构模式
维基百科：架构模式是在给定上下文的软件架构中，针对常发生问题的一种通用、复用的解决方案。架构模式类似于软件设计模式，但是范畴更广。
本文中，我将简要的阐述如下10中常见架构模式的应用和优缺点。
1. 分层模式
2. 客户端-服务端模式
3. 主从模式
4. 管道-过滤器模式
5. 代理模式
6. 点对点模式
7. 事件总线模式
8. 模型-视图-控制器模式
9. 黑板模式
10. 解释器模式
1. 分层模式
该模式用于构建可分解为多组子任务的程序，每个子任务都在某个抽象层，每个层对上一个更高层提供服务。一般信息系统中最常见的4层体系如下。
表示层（也叫 UI 层）应用层（也叫服务层）业务逻辑层（也叫领域层）数据访问层（也叫持久层） 应用场景一般桌面程序电子商务网页程序
2. 客户端-服务器模式
该模式由两部分构成：单个服务器端和多个客户端。服务器组件对多个客户端组件提供服务。客户端向服务器端请求服务，服务端提供对应服务给这些客户端。此外，服务器端继续监听客户端请求。
应用场景
在线应用，比如电子邮件、文档分享和银行业务
3. 主从模式
该模式由两部分构成：主节点和多个从节点。主节点组件向多个独立的从节点组件分派任务，并根据从节点返回结果计算出最终结果。
应用场景
数据库复制，主数据库被视为权威来源并同步到从数据库连接到计算系统的外围设备（主从驱动）
4. 管道-过滤器模式
该模式用于构建生产和处理数据流的系统。每个处理步骤封装在一个过滤器组件中。待处理的数据被传送到管道之中，这些管道可用于缓冲或者同步。
应用场景
编译器，接连的过滤器执行词义分析，语法分析，语义分析和代码生成生物资料学科的工作流
5. 代理模式
该模式用于构建组件解耦的分布式系统。这些组件通过远程调用彼此交互。代理组件负责多个组件的通信协调，服务器向代理公开他们的能力（服务和特性）；客户端从代理中获取服务，然后代理重定向客户端到注册服务库中一个合适的服务。
应用场景
消息队列软件，比如 Apache ActiveMQ、Apache Kafka、RabbitMQ 和 JBoss Messaging
6. 点对点模式
该模式中，各独立组件都叫对等点。对等点既可以作为客户端从其他对等点获取服务，也可作为服务端向其他对等点提供服务。对等点可作为客户端、或者服务端、或者两者，并且在不时间动态切换角色。
应用场景
文件分享网络，比如 Gnutella 和 G2多媒体协议，比如 P2PTV 和 PDTP私媒体程序，比如 Spotify
7. 事件总线模式
该模式主要处理事件，有4个主要组件：事件源，事件监听器，频道和事件总线。事件源发布消息到事件总线上的某个频道，监听器订阅某个频道，并得知在已订阅频道中发布的消息。
应用场景
Android 开发通知服务
8. 模型-视图-控制器模式
该模式也叫 MVC 模式，划分交互程序为3个部分：模型——包含核心功能和数据，视图——显示信息给用户（多个视图可被定义），控制器——处理用户输入。它通过分割用户信息的内部陈述和呈现、接受方式来实现，解耦组件并允许高效的代码复用。
应用场景
主流编程语言的万维网程序架构网页框架，比如 Django 和 Rails
9. 黑板模式
该模式对没有确定性方案策略的问题很有用。黑板模式由三个主要组件组成，黑板——包含解空间对象的结构化全局内存，知识源——有自拥表示的专门模块，控制组件——选择、配置和执行模块。所有组件都可访问黑板，可生成新的数据对象并添加到黑板中。在黑板中，可根据已有知识源的匹配规则，寻找某些类型的数据。
应用场景
语音识别车辆识别和跟踪蛋白质结构鉴定声呐信号解释
10. 解释器模式
该模式用于设计解释特定语言编写的程序的组件。该组件主要指定怎么去评估程序代码行，也就是所谓的用某种语[标签:内容]
图解几种常见的软件架构模式
本篇经验将和大家介绍几种常见的软件架构模式，希望对大家的工作和学习有所帮助！
方法/步骤分层模式
这种模式也称为多层体系架构模式。它可以用来构造可以分解为子任务组的程序，每个子任务都处于一个特定的抽象级别。每个层都为下一个提供更高层次服务。
一般信息系统中最常见的是如下所列的4层。
表示层(也称为UI层)
应用层(也称为服务层)
业务逻辑层(也称为领域层)
数据访问层(也称为持久化层)
使用场景：
一般的桌面应用程序
电子商务Web应用程序
客户端-服务器模式
这种模式由两部分组成：一个服务器和多个客户端。服务器组件将为多个客户端组件提供服务。客户端从服务器请求服务，服务器为这些客户端提供相关服务。此外，服务器持续侦听客户机请求。
使用场景：
电子邮件，文件共享和银行等在线应用程序
主从设备模式
这种模式由两方组成;主设备和从设备。主设备组件在相同的从设备组件中分配工作，并计算最终结果，这些结果是由从设备返回的结果。
使用场景：
在数据库复制中，主数据库被认为是权威的来源，并且要与之同步
在计算机系统中与总线连接的外围设备(主和从驱动器)
管道-过滤器模式
此模式可用于构造生成和处理数据流的系统。每个处理步骤都封装在一个过滤器组件内。要处理的数据是通过管道传递的。这些管道可以用于缓冲或用于同步。
使用场景：
编译器。连续的过滤器执行词法分析、解析、语义分析和代码生成
生物信息学的工作流
代理模式
此模式用于构造具有解耦组件的分布式系统。这些组件可以通过远程服务调用彼此交互。代理组件负责组件之间的通信协调。
服务器将其功能(服务和特征)发布给代理。客户端从代理请求服务，然后代理将客户端重定向到其注册中心的适当服务。
使用场景：
消息代理软件，如Apache ActiveMQ，Apache Kafka，RabbitMQ和JBoss Messaging
点对点模式
在这种模式中，单个组件被称为对等点。对等点可以作为客户端，从其他对等点请求服务，作为服务器，为其他对等点提供服务。对等点可以充当客户端或服务器或两者的角色，并且可以随时间动态地更改其角色。
使用场景：
像Gnutella和G2这样的文件共享网络
多媒体协议，如P2PTV和PDTP
像Spotify这样的专有多媒体应用程序
事件总线模式
这种模式主要是处理事件，包括4个主要组件：事件源、事件监听器、通道和事件总线。消息源将消息发布到事件总线上的特定通道上。侦听器订阅特定的通道。侦听器会被通知消息，这些消息被发布到它们之前订阅的一个通道上。
使用场景：
安卓开发
通知服务
模型-视图-控制器模式
这种模式，也称为MVC模式，把一个交互式应用程序划分为3个部分，
模型：包含核心功能和数据
视图：将信息显示给用户(可以定义多个视图)
控制器：处理用户输入的信息
这样做是为了将信息的内部表示与信息的呈现方式分离开来，并接受用户的请求。它分离了组件，并允许有效的代码重用。
使用场景：
在主要编程语言中互联网应用程序的体系架构
像Django和Rails这样的Web框架
黑板模式
这种模式对于没有确定解决方案策略的问题是有用的。黑板模式由3个主要组成部分组成。
黑板——包含来自解决方案空间的对象的结构化全局内存
知识源——专门的模块和它们自己的表示
控制组件——选择、配置和执行模块
所有的组件都可以访问黑板。组件可以生成添加到黑板上的新数据对象。组件在黑板上查找特定类型的数据，并通过与现有知识源的模式匹配来查找这些数据。
使用场景：
语音识别
车辆识别和跟踪
蛋白质结构识别
声纳信号的解释
解释器模式
这个模式用于设计一个解释用专用语言编写的程序的组件。它主要指定如何评估程序的行数，即以特定的语言编写的句子或表达式。其基本思想是为每种语言的符号都有一个分类。
使用场景：
数据库查询语言，比如SQL
用于描述通信协议的语言
各位，23种设计模式都在哪些场合运用到
其中创建型有：
一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点
例如：随处可见，比如Servlet，sprigMVC创建时都是单例多线程的。
完美的实例是：private static Singleton instance = new Singleton();
创建线程的方式有很多种，但是很多都扛不住多线程的检验，上面是简单又实用的例子，多线程下也是安全的。
二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
例如：虽然简单工厂（静态工厂）没有进入23种设计模式，但是java web中的很多配置文件玩的还是它。
Spring中下面三种方式实例化bean：
1.使用类构造器实例化
2.使用静态工厂方法实例化
public class OrderFactory {
public static OrderServiceBean createOrder(){
return new OrderServiceBean();
}
}
3.使用实例工厂方法实例化:
public class OrderFactory {
public OrderServiceBean createOrder(){
return new OrderServiceBean();
}
}
第一种方法，IOC容易直接根据配置文件中的class属性通过反射创建一个实例，使用的是该类的默认构造方法。第二种则是调用class指定的工厂类的
工厂方法，来返回一个相应的bean实例，值得注意的是工厂类的方法是静态方法，所以不用产生工厂本身的实例。而第三种则不同，它除了配置与第二种相同
外，唯一的不同就是方法不是静态的，所以创建bean的实例对象时需要先生成工厂类的实例。实例了bean对象时，需要对其中的属性也进行赋值，这时就是经常被提及的依赖注入。
以上其实有错误：Spring很多情况下创建对象很定是反射呀，尤其是注解和DI（依赖注入），小朋友，想什么呢？肯定不是用new()来创建：
Class c = Class.forName("cn.itcast.OrderServiceBean");
Object bean = c.newInstance();
四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
行为型有：
六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
例如：jdk中的各种容器类的基础模式
七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
例如：据说是jdk使用最多的模式,好比邮件订阅或RSS订阅
八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。
十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
例如：comparator 比较器的实现利用了此模式
十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 。
此处强调一点就是，链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象
例如：struts2 interceptor 用到的就是是责任链模式
十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。
十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
结构型有：
十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。
十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，facade提供了一高层接口，这个接口使得子系统更容易使用。
十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问。
例如：经典的体现在Spring AOP切面中，Spring中利用了俩种代理类型。
其实，代理也分为静态和动态，但是我们一般常用动态，因为静态代理秀不起来
二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
其中对象的适配器模式是各种结构型模式的起源，分为三种：类，对象，接口的适配器模式。
结一下三种适配器模式的应用场景：
类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。
接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。
例如：java io流中大量使用
二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。
对比：适配器模式主要是为了接口的转换，而装饰者模式关注的是通过组合来动态的为被装饰者注入新的功能或行为(即所谓的责任)。
二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。
二十三、Flyweight，享元模式：主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。
例如：数据库连接池便是这个原理
设计模式（五）行为型模式
在上一篇结构型模式中，我们以功能为基本单位，研究了一些设计模式，用于实现功能转换、功能组合、功能封装等目的。
我们知道，面向对象编程有两个核心元素：对象、对象间通信协作。从面向对象的角度看，任何系统和功能，都是由一个个对象，相互分工合作实现的。推而广之，很多系统也都是这样组织和运行的。
本章的设计模式，列举了通用场景下常用功能机制的经典实现方法，讲解了经典实现中是如何高效组织对象、控制对象协作交互的，具有很好的参考价值。
示例：https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html
责任链模式，就是把程序处理对象前后排列起来，形成一条处理线。处理线上需要被处理的信息，在处理线上向下传递，任何一个节点都可以随时中断传递。
GUI系统中的事件传递机制（在Javascript中叫做事件冒泡），是责任链模式最典型的应用之一。
当某一事件发生时，最顶层GUI对象会首先收到事件，但是它先不处理，而是依次交给命中的子GUI对象处理。当子GUI对象返回为False时，表示事件未被接收，此时父GUI对象才真正对发生的事件进行业务处理。
可以看出，事件传递机制，是一种增强版的责任链模式，它的节点处理权，经历了向下和向上的双向传递过程。
总结：当项目中一个数据对象，需要被多个处理对象进行处理时，可以将处理对象链接起来，然后把数据对象传递给头节点，随着处理的进行，数据对象的处理权会在处理链中流动，从而完成整个处理过程。
责任链模式结构适用于需求固定的场景，用于实现简单高效的处理机制。假如需求不断变化，而且功能很复杂，那么用责任链模式很可能就无法胜任了，需要采用新的高复杂度的设计。例如，如果想要数据对象在所有处理对象中根据状态来实现跳转，可以选择使用状态机等其他方案来实现。
示例：https://www.runoob.com/design-pattern/command-pattern.html
想要实现撤销、重做、事务等功能，可以使用此设计模式。通常在编辑器、数据库中有此类功能需求。
命令也就是请求，或者叫调用。命令模式要求将请求参数和请求相关的方法封装在一起。
请求对象中封装了实现“撤销”、“重做”、“事务”功能所需要的所有信息，实现了关联信息的高内聚，所以可以实现我们想要的功能。
例如，可以在请求对象中保存修改之前的值、修改之后的值。利用修改之前的值，可以实现“撤销”功能；利用修改之后的值，可以实现“重做”功能。如果将所有请求对象都记录下来，并按照先后顺序排列起来，形成“撤销重做”堆栈，这样就可以实现连续的“撤销”、“重做”。“事务”则是“撤销”与“重做”的结合体，正常执行流程等同于“重做”，发生错误需要回滚，等同于“撤销”。
如果不采用这种方式，会导致实现这些功能的信息，分散在源码中多个地方，或者已经丢失，没有保存，就无法实现“撤销”、“重做”、“事务”功能。
同时，实现请求参数高内聚，也可以很方便地将它们保存到磁盘上，保存到文件的过程叫做“序列化”，从文件中读取的过程叫“反序列化”。这里的序列指的就是二进制流。
Qt中与命令模式相关的部分是：Undo Framework，里面有示例项目，不熟悉的同学可以抽点时间看一看。
示例：https://www.runoob.com/design-pattern/interpreter-pattern.html
顾名思义，解释器模式是用来实现解释器的。 解释器是这样一个程序：解释器以符合语法的文本为输入，解释输入内容，完成一定的计算功能。文本可以在程序运行时动态加载，动态解释、动态执行。
实现简单的解释器：命令行程序，如ping命令、cd命令等； 实现复杂的解释器：脚本语言解释器，如python，lua，javascript；计算器。
我们知道，在GUI图形用户界面被发明之前，人类和程序之间的交互是通过敲命令行实现的，缺点是使用难度较大，门槛较高。 在GUI发明以后，交互更加友好，电脑更加易于使用了，所以也更加普及了。
但是GUI交互的缺点在于，不够灵活，对参数的控制粒度不够细致。例如，现在大多数开发者都使用集成开发环境来开发软件，一般情况下都使用默认参数，比较方便。但是如果你想要更改某些编译选项，可能还是需要直接修改底层的编译命令。命令相对于GUI元素更加灵活，过于灵活的地方用GUI比较难于实现，例如组合、递归、跳转等等。在这些场景下，使用解释器是非常合适的。但是通常情况下，这个模式并不常用。
示例：https://www.runoob.com/design-pattern/iterator-pattern.html
在需要多次遍历同一个数据集合的时候，为了少些一些for，或者想要把遍历过程封装起来，降低耦合，就可以使用迭代器模式。这个模式非常常用。
迭代器就是一个专门用来遍历数组的类。它只需要实现两个接口：hasNext()、next()。 hasNext()接口用于控制循环何时停止；next()接口用于取出当前位置的数据元素，并将遍历指针指向下一个元素。 当然，构造迭代器对象的时候，需要将数据集合传递给迭代器，让迭代器知道要遍历哪些数据。
原本需要用for循环来遍历的代码，现在通过封装，提取出了“遍历”这一功能所需要的必要信息，定义了两个接口，把不必要暴露的信息封装在了迭代器中，妥妥的实现了解耦。
示例：https://www.runoob.com/design-pattern/mediator-pattern.html
中介者模式是指，在原本直接通信的对象之间，添加一个通信中间层，使对象间通信变为间接通信，降低对象间的耦合。
此模式和代理模式基本思想上是一致的。二者的区别是：代理模式是通过加一个中间层，来实现两个原本很难交互的功能主体，实现顺畅交互；中介者模式是为了降低对象间通信时的耦合而提出的，为的是提高代码的可维护性。
比较大的项目中会用到，一般存在于某些框架中。因为大的项目中对象繁多，通信也比较复杂，适合使用中介者模式。
在大的项目中，一般会有一个全局的通信管理器，任何对象都可以使用通信管理器提供的接口，将自己注册为某一个具有唯一ID消息的发送者和接收者。这样发送者只需要发送消息，不需要管谁来接收，不需要拥有发送者的实例指针，发出消息后，已注册的接收者都会收到消息。接收者不需要管信号是谁发的，即不需要拥有发送者的实例指针。
所以，中介者模式也可以叫“通信中介模式”。
示例：https://www.runoob.com/design-pattern/memento-pattern.html
这个模式和状态存档功能是绑定在一起的。为了在程序中实现状态存档功能，可以使用备忘录模式。
原例子中有三个类，个人觉得没有必要，这里我们简化成两个类，即备忘录模式中有两个类：状态对象类和状态对象管理类。 状态对象类是状态字段是集合，并提供了存取接口；状态对象管理类负责组织和保存状态对象。当然实际实现中可以根据需求增加类，配合使用，完成状态保存恢复。
当一个对象会影响到其他多个对象时，即当对象间存在一对多关系时，使用观察者模式。 一般应用于单向通知的场景，如GUI中鼠标事件、按键事件、窗口事件通知。使用Qt中的信号槽机制可以实现此模式。
“一”是指发生变化的那个对象，“多”是指需要获取此变化通知的对象组。其中，变化消息是单向地由“一”到“多”传递的。如果不是单向的或者对象间不是一对多的关系，更加复杂，就需要重新思考其他对象间通信模型。
如果不使用此模式，可能会导致观察者不能动态增加或删除；可能会造成发送者的业务代码和接收者的响应代码混在一起，耦合严重。
使用此模式，需要为观察者设计一个基类，并设计一个接收通知的接口，所有观察者需要实现通知接口；所有观察者指针可以保存在队列中，实现动态增删。
状态模式用于实现状态机。 如果一个程序功能中存在某些状态，在一定情况下，这些状态可以互相转换，并且在转换前后需要作出对应的操作，这种情况下使用状态机来实现就非常合适。
如果不使用状态机（状态模式），一般的实现方法是使用一连串的if-else，或者使用长长的switch-case来实现。这样做的缺点，一方面状态判断不够高效，另一方面是业务代码集中在一块，不好维护。
使用状态机，每个状态都是一个类，相关的业务代码分布到各自的状态类中，能够实现不同的状态及与状态相关的业务代码解耦。同时某个状态和下一个状态是关联好的，在状态切换时，效率更高，不需要执行长长的判断。
Qt中已实现状态机框架，The State Machine Framework，在此框架下，我们可以更加专注于业务实现，而不是状态机本身的技术细节。
示例：https://www.runoob.com/design-pattern/null-object-pattern.html
使用基类保存子类对象通常有两种做法：
第一种方法用指针是基本方法，但是指针用起来要非常小心，要考虑内存释放的问题。此时空对象就可以用空指针表示。 第二种方法用基类对象保存子类对象，这种方法使用起来相对省心，不用与指针打交道，使用者不用直接管理内存。例如Qt中的Qt XML C++ Classes类的设计就是采用这种方式设计的。这种情况下，因为不使用指针，就需要使用空对象来代替空指针。
可以仿造Qt XML中的类进行设计。一般需要提供isNull()接口，对象类型转换接口等。
策略模式和桥接模式类似，用于实现功能切换与组合。二者区别在于，策略模式专注于一个功能的不同实现方式；桥接模式专注于多个功能之间的组合。
将功能抽象成单独的类，功能切换只需要切换不同的功能子类即可，同一个功能需要实现同一个功能接口。
示例：https://www.runoob.com/design-pattern/template-pattern.html
模板模式应该是我们最熟悉的。 这里的模板就是接口类，接口类定义了使用者和功能提供者之间交互的函数列表。子类负责功能的具体实现。
示例：https://www.runoob.com/design-pattern/visitor-pattern.html
访问者模式用于将数据结构与数据操作相分离。
访问者模式和迭代器模式类似。迭代器模式一般用来遍历数组，所以没有把for封装起来。而访问者模式可以遍历一切类型的数据结构，具体的遍历过程被封装在接收者内部。同时，对每一个遍历得到的数组元素的操作，被封装在访问者内部。每一种对元素不同的操作，都需要新建一个访问者类。
接收者需要实现accept()接口，访问者需要实现visit()接口。
每种设计模式都有使用场景，都有优点和缺点。随着需求的改变，任何一种设计模式可能都将不再适用。
java常用的设计模式一共有多少种(java常用的设计模式及应用场景)
1、java中存在23种面向对象的设计模式，分别是：
1）创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
2）结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
3）行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
2、他们遵从如下原则：
1）单一职责原则
2）里式替换原则
3）依赖倒置原则
4）接口隔离原则
5）迪米特法则
6）开闭原则
java中常用到得设计模式有哪几种(java常用的设计模式及应用场景)
一共23种设计模式！
按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。
创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
工厂方法模式（FactoryMethodPattern）
抽象工厂模式（AbstractFactoryPattern）
建造者模式（BuilderPattern）
原型模式（PrototypePattern）
单例模式（SingletonPattern）
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
适配器模式（AdapterPattern）
桥接模式（BridgePattern）
组合模式（CompositePattern）
装饰者模式（DecoratorPattern）
外观模式（FacadePattern）
享元模式（FlyweightPattern）
代理模式（ProxyPattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
责任链模式（ChainofPattern）
命令模式（CommandPattern）
解释器模式（InterpreterPattern）
迭代器模式（IteratorPattern）
中介者模式（MediatorPattern）
备忘录模式（MementoPattern）
观察者模式（ObserverPattern）
状态模式（StatePattern）
策略模式（StrategyPattern）
模板方法模式（TemplateMethodPattern）
访问者模式（VisitorPattern）
推荐你一本好书：《软件秘笈：设计模式那点事》，里面讲解的23中设计模式例子很生动，容易理解，还有JDK中设计模式应用情况，看了收获挺大的！百度里面搜“设计模式”，第一条中设计模式百度百科中就有首推该图书，浏览量在20几万以上的，不会错的。好东西大家一起分享！
祝你早日学会设计模式！
设计模式都有哪些？
设计模式主要分三个类型:创建型、结构型和行为型。
其中创建型有：
一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点
二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
行为型有：
六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。
十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系
十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。
十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
结构型有：
十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。
十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。
十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问
二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。
二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。
二十三、Flyweight，享元模式
一共23种设计模式！
引用《软件秘笈：设计模式那点事》书籍：
按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。
创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
? 工厂方法模式（Factory Method Pattern）
? 抽象工厂模式（Abstract Factory Pattern）
? 建造者模式（Builder Pattern）
? 原型模式（Prototype Pattern）
? 单例模式（Singleton Pattern）
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
? 适配器模式（Adapter Pattern）
? 桥接模式（Bridge Pattern）
? 组合模式（Composite Pattern）
? 装饰者模式（Decorator Pattern）
? 外观模式（Facade Pattern）
? 享元模式（Flyweight Pattern）
? 代理模式（Proxy Pattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
? 责任链模式（Chain of Responsibility Pattern）
? 命令模式（Command Pattern）
? 解释器模式（Interpreter Pattern）
? 迭代器模式（Iterator Pattern）
? 中介者模式（Mediator Pattern）
? 备忘录模式（Memento Pattern）
? 观察者模式（Observer Pattern）
? 状态模式（State Pattern）
? 策略模式（Strategy Pattern）
? 模板方法模式（Template Method Pattern）
? 访问者模式（Visitor Pattern）
《软件秘笈：设计模式那点事》中讲解的23中设计模式例子很生动，容易理解，还有JDK中设计模式应用情况，看了收获挺大的！好东西大家一起分享！
祝你早日学会设计模式！
三种大类型类型：创建型模式 Creational Pattern、结构型模式 Structural Pattern 、行为型模式 Behavioral Pattern
创建型模式 Creational Pattern包括：单例模式，简单工厂模式，工厂方法模式，抽象工厂模式，原型模式，建造者模式
结构型模式 Structural Pattern包括： 适配器模式，桥接模式，组合模式，装饰模式，外观模式，享元模式，代理模式
行为型模式 Behavioral Pattern包括：职责链模式，命令模式，解释器模式，迭代器模式，中介者模式，备忘录模式，观察者模式，状态模式，策略模式，模板方法模式，访问者模式
具体了解可参见下面链接（C++代码示例）
设计模式之模式概述（C++示例）（设计模式汇总）
单例模式
工厂模式
这两个比较常用，还有很多。
总体来说设计模式分为三大类：
一、创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
二、结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
三、行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1、工厂方法模式：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。
工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，这就用到工厂方法模式。
创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
2、抽象工厂模式：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承。
3、单例模式：
单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：
（1）某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
（2）省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
（3）有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
4、建造者模式：
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
5、原型模式：
原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类。
6、适配器模式：
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
7、装饰器模式：
顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
8、代理模式：
代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。
9、外观模式：
外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口。
10、桥接模式：
桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样。
JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。
11、组合模式：
组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。
12、享元模式：
享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。
13、策略模式：
策略模式定义了一系列算法，并将每个算法封装起来，使其可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。
14、模板方法模式：
一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。
15、观察者模式：
观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。
其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
16、迭代子模式：
顾名思义，迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
17、责任链模式：
责任链模式，有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。
18、命令模式：
命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开。
19、备忘录模式：
主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。
20、状态模式：
状态模式在日常开发中用的挺多的，尤其是做网站的时候，我们有时希望根据对象的某一属性，区别开他们的一些功能，比如说简单的权限控制等。
21、访问者模式：
访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。
若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。
22、中介者模式：
中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。
如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用。
23、解释器模式：
解释器模式一般主要应用在OOP开发中的编译器的开发中，所以适用面比较窄。
扩展资料：
介绍三本关于设计模式的书：
1、《设计模式：可复用面向对象软件的基础》
作者：[美] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
出版社： 机械工业出版社
2、《软件秘笈：设计模式那点事》
作者：郑阿奇
出版社：电子工业出版社
3、《设计模式：基于C#的工程化实现及扩展》
作者：王翔
出版社：电子工业出版社
参考资料来源：百度百科-设计模式
Java开发中的23种设计模式详解(转)_Java开发模式
设计模式（Design Patterns）
——可复用面向对象软件的基础
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
一、设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：
二、设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。
里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。
LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。
三、Java的23中设计模式
从这一块开始，我们详细介绍Java中23种设计模式的概念，应用场景等情况，并结合他们的特点及设计模式的原则进行分析。
1、工厂方法模式（Factory Method）
工厂方法模式分为三种：
11、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：
举例如下：（我们举一个发送邮件和短信的例子）
首先，创建二者的共同接口：
[java]view plaincopy publicinterfaceSender{publicvoidSend();}
其次，创建实现类：
[java]view plaincopy publicclassMailSenderimplementsSender{@OverridepublicvoidSend(){System.out.println("thisismailsender!");}} [java]view plaincopy publicclassSmsSenderimplementsSender{@OverridepublicvoidSend(){System.out.println("thisissmssender!");}}
最后，建工厂类：
[java]view plaincopy publicclassSendFactory{publicSenderproduce(Stringtype){if("mail".equals(type)){returnnewMailSender();}elseif("sms".equals(type)){returnnewSmsSender();}else{System.out.println("请输入正确的类型!");returnnull;}}}
我们来测试下：
publicclassFactoryTest{publicstaticvoidmain(String[]args){SendFactoryfactory=newSendFactory();Sendersender=factory.produce("sms");sender.Send();}}
输出：this is sms sender!
22、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。关系图：
将上面的代码做下修改，改动下SendFactory类就行，如下：
[java]view plaincopypublicclassSendFactory{publicSenderproduceMail(){ returnnewMailSender();}publicSenderproduceSms(){returnnewSmsSender();}}
测试类如下：
[java]view plaincopy publicclassFactoryTest{publicstaticvoidmain(String[]args){SendFactoryfactory=newSendFactory();Sendersender=factory.produceMail();sender.Send();}}
输出：this is mailsender!
33、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
[java]view plaincopy publicclassSendFactory{publicstaticSenderproduceMail(){returnnewMailSender();}publicstaticSenderproduceSms(){returnnewSmsSender();}} [java]view plaincopy publicclassFactoryTest{publicstaticvoidmain(String[]args){Sendersender=SendFactory.produceMail();sender.Send();}}
输出：this is mailsender!
总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。
2、抽象工厂模式（Abstract Factory）
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。
请看例子：
[java]view plaincopy publicinterfaceSender{publicvoidSend();}
两个实现类：
[java]view plaincopy publicclassMailSenderimplementsSender{@OverridepublicvoidSend(){System.out.println("thisismailsender!");}} [java]view plaincopy publicclassSmsSenderimplementsSender{@OverridepublicvoidSend(){System.out.println("thisissmssender!");}}
两个工厂类：
[java]view plaincopy publicclassSendMailFactoryimplementsProvider{@OverridepublicSenderproduce(){returnnewMailSender();}} [java]view plaincopy publicclassSendSmsFactoryimplementsProvider{@OverridepublicSenderproduce(){returnnewSmsSender();}}
在提供一个接口：
[java]view plaincopy publicinterfaceProvider{publicSenderproduce();}
测试类：
[java]view plaincopy publicclassTest{publicstaticvoidmain(String[]args){Providerprovider=newSendMailFactory();Sendersender=provider.produce();sender.Send();}}
其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！
3、单例模式（Singleton）
单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类：
[java]view plaincopy publicclassSingleton{/*持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载*/privatestaticSingletoninstance=null;/*私有构造方法，防止被实例化*/privateSingleton(){}/*静态工程方法，创建实例*/publicstaticSingletongetInstance(){if(instance==null){instance=newSingleton();}returninstance;}/*如果该对象被用于序列化，可以保证对象在序列化前后保持一致*/publicObjectreadResolve(){returninstance;}}
这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对getInstance方法加synchronized关键字，如下：
[java]view plaincopy publicstaticsynchronizedSingletongetInstance(){if(instance==null){instance=newSingleton();}returninstance;}
但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个：
[java]view plaincopy publicstaticSingletongetInstance(){if(instance==null){synchronized(instance){if(instance==null){instance=newSingleton();}}}returninstance;}
似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。但是，这样的情况，还是有可能有问题的，看下面的情况：在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就可能出错了，我们以A、B两个线程为例：
a>A、B线程同时进入了第一个if判断
b>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
c>由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
e>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。
所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化：
[java]view plaincopy privatestaticclassSingletonFactory{privatestaticSingletoninstance=newSingleton();}publicstaticSingletongetInstance(){returnSingletonFactory.instance;}
实际情况是，单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式：
[java]view plaincopy publicclassSingleton{/*私有构造方法，防止被实例化*/privateSingleton(){}/*此处使用一个内部类来维护单例*/privatestaticclassSingletonFactory{privatestaticSingletoninstance=newSingleton();}/*获取实例*/publicstaticSingletongetInstance(){returnSingletonFactory.instance;}/*如果该对象被用于序列化，可以保证对象在序列化前后保持一致*/publicObjectreadResolve(){returngetInstance();}}
其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。也有人这样实现：因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字，也是可以的：
[java]view plaincopy publicclassSingletonTest{privatestaticSingletonTestinstance=null;privateSingletonTest(){}privatestaticsynchronizedvoidsyncInit(){if(instance==null){instance=newSingletonTest();}}publicstaticSingletonTestgetInstance(){if(instance==null){syncInit();}returninstance;}}
考虑性能的话，整个程序只需创建一次实例，所以性能也不会有什么影响。
补充：采用"影子实例"的办法为单例对象的属性同步更新
[java]view plaincopy publicclassSingletonTest{privatestaticSingletonTestinstance=null;privateVectorproperties=null;publicVectorgetProperties(){returnproperties;}privateSingletonTest(){}privatestaticsynchronizedvoidsyncInit(){if(instance==null){instance=newSingletonTest();}}publicstaticSingletonTestgetInstance(){if(instance==null){syncInit();}returninstance;}publicvoidupdateProperties(){SingletonTestshadow=newSingletonTest();properties=shadow.getProperties();}}
通过单例模式的学习告诉我们：
1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。
2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。
到这儿，单例模式基本已经讲完了，结尾处，笔者突然想到另一个问题，就是采用类的静态方法，实现单例模式的效果，也是可行的，此处二者有什么不同？
首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态了。因为接口中不允许有static修饰的方法，所以即使实现了也是非静态的）
其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载，是因为有些类比较庞大，所以延迟加载有助于提升性能。
再次，单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。
最后一点，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你可以在里面随心所欲的实现一些其它功能，但是静态类不行。从上面这些概括中，基本可以看出二者的区别，但是，从另一方面讲，我们上面最后实现的那个单例模式，内部就是用一个静态类来实现的，所以，二者有很大的关联，只是我们考虑问题的层面不同罢了。两种思想的结合，才能造就出完美的解决方案，就像HashMap采用数组+链表来实现一样，其实生活中很多事情都是这样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是，结合各个方法的优点，才能最好的解决问题！
4、建造者模式（Builder）
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码：
还和前面一样，一个Sender接口，两个实现类MailSender和SmsSender。最后，建造者类如下： [java]view plaincopy publicclassBuilder{privateList list=newArrayList ();publicvoidproduceMailSender(intcount){for(inti=0;i0){pos--;}returncollection.get(pos);}@OverridepublicObjectnext(){if(pos
大牛带你了解：在JDK中，运用了哪些设计模式？
作者：肥朝
参考外国文献：http://h5ip.cn/lPtD
适配器模式：
肥朝小声叨叨：在我们业务代码中经常有新旧接口适配需求，可以采用该模式。
桥接模式：
肥朝小声逼逼：这个模式，其实我们每天都在用到，但是你可能却浑然不知。只要你用到面向接口编程，其实都是在用桥接模式。
组合模式
肥朝小声逼逼：从上面那句英文我们就可以得知，组合模式常用于递归操作的优化上，比如每个公司都有个boss系统，都会有什么菜单的功能。比如一级菜单下有二级菜单，二级菜单又有三级菜单。删除一级菜单的时候需要不断删除子菜单，那么这个设计模式你可以试试。总之，凡是有级联操作的，你都可以尝试这个设计模式。
装饰者模式
肥朝小声逼逼：这个模式使用就太广了，我们常用的AOP，既有动态代理，也有装饰者的味道。
门面模式
肥朝小声逼逼：我们每天使用的SLFJ日志就是门面日志，比如我们使用Dubbo，向外提供的服务就尽量采用门面模式，然后服务在调用各种service做聚合。
享元模式
肥朝小声逼逼：只要用到了缓存，基本都是在使用享元模式。很多同学都说自己的项目太low了，都没有用到什么设计模式，这不是开玩笑吗，你用个map缓存几个对象，基本上都运用了享元的思想。
代理模式
肥朝小声逼逼：代理模式用得很广泛，基本所有大家知道的开源框架，都用到了动态代理。
抽象工厂模式
肥朝小声逼逼：从英文就可以得出，该模式可以与策略模式结合使用。
建造者模式
肥朝小声逼逼：这个在我们业务代码中使用的场景太广泛了。比如订单系统大部分项目都有，订单对象就是一个复杂对象，我们就可以采用建造者模式来做。
工厂方法
肥朝小声逼逼：这个属于大家都会的设计模式，不多过介绍。
原型模式
肥朝小声逼逼：这个你以为是冷门的设计模式，其实错了，这个是大热门的设计模式。比如我们业务代码，经常要各种DTO、BO、DO、VO转换，其实就可以参考原型设计模式的思想来做。
单例模式
肥朝小声逼逼：在平时开发中，单例是我们用得最多的了，因为Spring的bean，默认就是单例级别的。单例属于大家基本都会的设计模式。
责任链
肥朝小声逼逼：凡是带有Filter关键词的，基本都在用这个设计模式。在业务代码使用的场景实在是太多了，用到拦截器的地方基本都在用这个设计模式。
命令模式
肥朝小声逼逼：命令模式使用频率较高，和策略模式比较像，具体区别可以搜索一下。如果用过Activiti工作流引擎的朋友可以看一下里面的源码，很多地方都用到了命令模式。
解释器模式
迭代器模式
肥朝小声逼逼：这个中间件和基础框架组的同学可能用得比较多，业务代码的话用得不多，不过JDK中的这种使用很经典，可以看看。
中介者模式
备忘录模式
空对象模式
肥朝小声逼逼：这个业务代码用得不多，但是JDK中的这几个方法我们倒是挺常用的。
观察者模式
肥朝小声逼逼：我们业务代码一般是基于Zookeeper来做观察者的。基本上用到ZK的地方，都是在用观察者模式，比如分布式锁，比如服务发现等。
状态模式
肥朝小声逼逼：这个在业务代码用得就太广泛了，我就不信你们系统还没有“状态”了。比如我们常见的订单状态或者各种XX状态，都可以用得上。
策略模式
模板方法模式
肥朝小声逼逼：这个模式也是非常高频的模式。业务代码中经常遇到有很多相同的部分，我们可以做一个抽象类，子类来实现差异化，如果还不知道的，赶紧搜索一下，再次强调，非常高频。
访问者模式
你项目都用到了哪些设计模式？亦或者上述设计模式你在实际业务代码中有更好的场景？