JAVA设计模式总结之23种设计模式

布满荆棘的人生 2022-12-11 11:28 203阅读 0赞

**一、什么是设计模式  **

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。简单说：

**模式：在某些场景下，针对某类问题的某种通用的解决方案。**

场景：项目所在的环境

问题：约束条件，项目目标等

解决方案：通用、可复用的设计，解决约束达到目标。

**二、设计模式的三个分类                                                                                                                                **

**创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。**

**结构型模式：把类或对象结合在一起形成一个更大的结构。**

**行为型模式：类和对象如何交互，及划分责任和算法。**

**如下图所示：**

![043c778173f5d7a1ca8b92261bc4036b.png][]

**三、各分类中模式的关键点                                                                                                                             **

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

简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。

工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。

抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。

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

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

适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。

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

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

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

亨元（蝇量）模式：通过共享技术来有效的支持大量细粒度的对象。

外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。

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

模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。

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

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

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

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

中介者模式：用一个中介对象来封装一系列的对象交互。

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

访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。

责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。

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

**四、概说23种设计模式                                                                                                                                    **

1.单例模式

单例模式，它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。

单例模式具备典型的3个特点：1、只有一个实例。 2、自我实例化。 3、提供全局访问点。

因此当系统中只需要一个实例对象或者系统中只允许一个公共访问点，除了这个公共访问点外，不能通过其他访问点访问该实例时，可以使用单例模式。

单例模式的主要优点就是节约系统资源、提高了系统效率，同时也能够严格控制客户对它的访问。也许就是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，所以扩展起来有一定的困难。其UML结构图非常简单，就只有一个类，如下图：

![2cead0e26750b69c5c194259d45b35a2.png][]

2.工厂方法模式

作为抽象工厂模式的孪生兄弟，工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，也就是说工厂方法模式让实例化推迟到子类。

工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。虽然他很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。其UML结构图：

![fe259853ed3a706b7d9252b12d880a59.png][]

3.抽象工厂模式

所谓抽象工厂模式就是提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。他允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了，而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更加需要更改接口及其下所有子类。其UML结构图如下：

![d2490c2978f74ab93a0475851d372f69.png][]

4.建造者模式

对于建造者模式而已，它主要是将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。适用于那些产品对象的内部结构比较复杂。

建造者模式将复杂产品的构建过程封装分解在不同的方法中，使得创建过程非常清晰，能够让我们更加精确的控制复杂产品对象的创建过程，同时它隔离了复杂产品对象的创建和使用，使得相同的创建过程能够创建不同的产品。但是如果某个产品的内部结构过于复杂，将会导致整个系统变得非常庞大，不利于控制，同时若几个产品之间存在较大的差异，则不适用建造者模式，毕竟这个世界上存在相同点大的两个产品并不是很多，所以它的使用范围有限。其UML结构图：

![3bca3a51b180ea87a1f034d1b0f07369.png][]

5.原型模式

在我们应用程序可能有某些对象的结构比较复杂，但是我们又需要频繁的使用它们，如果这个时候我们来不断的新建这个对象势必会大大损耗系统内存的，这个时候我们需要使用原型模式来对这个结构复杂又要频繁使用的对象进行克隆。所以原型模式就是用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

它主要应用与那些创建新对象的成本过大时。它的主要优点就是简化了新对象的创建过程，提高了效率，同时原型模式提供了简化的创建结构。UML结构图：

![770c140eae6bd1725a6219aed557e7fe.png][]

**模式结构**  
原型模式包含如下角色：  
Prototype：抽象原型类  
ConcretePrototype：具体原型类  
Client：客户类

6.适配器模式

在我们的应用程序中我们可能需要将两个不同接口的类来进行通信，在不修改这两个的前提下我们可能会需要某个中间件来完成这个衔接的过程。这个中间件就是适配器。所谓适配器模式就是将一个类的接口，转换成客户期望的另一个接口。它可以让原本两个不兼容的接口能够无缝完成对接。

作为中间件的适配器将目标类和适配者解耦，增加了类的透明性和可复用性。

![30b7387c19ec7c98188981d3fe9002a8.png][]

适配器模式包含如下角色：  
Target：目标抽象类  
Adapter：适配器类  
Adaptee：适配者类  
Client：客户类

7.桥接模式

如果说某个系统能够从多个角度来进行分类，且每一种分类都可能会变化，那么我们需要做的就是讲这多个角度分离出来，使得他们能独立变化，减少他们之间的耦合，这个分离过程就使用了桥接模式。所谓桥接模式就是讲抽象部分和实现部分隔离开来，使得他们能够独立变化。

桥接模式将继承关系转化成关联关系，封装了变化，完成了解耦，减少了系统中类的数量，也减少了代码量。

![3914047275463f513921ae9f79bc6799.png][]

桥接模式包含如下角色：  
Abstraction：抽象类  
RefinedAbstraction：扩充抽象类  
Implementor：实现类接口  
ConcreteImplementor：具体实现类

8.组合模式

组合模式组合多个对象形成树形结构以表示“整体-部分”的结构层次。它定义了如何将容器对象和叶子对象进行递归组合，使得客户在使用的过程中无须进行区分，可以对他们进行一致的处理。在使用组合模式中需要注意一点也是组合模式最关键的地方：叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

虽然组合模式能够清晰地定义分层次的复杂对象，也使得增加新构件也更容易，但是这样就导致了系统的设计变得更加抽象，如果系统的业务规则比较复杂的话，使用组合模式就有一定的挑战了。

![bf858398addf08eae799a20a9a3c2a7e.png][]

**模式结构**  
组合模式包含如下角色：  
Component: 抽象构件  
Leaf: 叶子构件  
Composite: 容器构件  
Client: 客户类

9.装饰模式

我们可以通过继承和组合的方式来给一个对象添加行为，虽然使用继承能够很好拥有父类的行为，但是它存在几个缺陷：一、对象之间的关系复杂的话，系统变得复杂不利于维护。二、容易产生“类爆炸”现象。三、是静态的。在这里我们可以通过使用装饰者模式来解决这个问题。

装饰者模式，动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更加有弹性的替代方案。虽然装饰者模式能够动态将责任附加到对象上，但是他会产生许多的细小对象，增加了系统的复杂度。

![0bde191d8ba06f44e57ee4860288abed.png][]

**模式结构**  
装饰模式包含如下角色：  
Component: 抽象构件  
ConcreteComponent: 具体构件  
Decorator: 抽象装饰类  
ConcreteDecorator: 具体装饰类

10.外观模式

我们都知道类与类之间的耦合越低，那么可复用性就越好，如果两个类不必彼此通信，那么就不要让这两个类发生直接的相互关系，如果需要调用里面的方法，可以通过第三者来转发调用。外观模式非常好的诠释了这段话。外观模式提供了一个统一的接口，用来访问子系统中的一群接口。它让一个应用程序中子系统间的相互依赖关系减少到了最少，它给子系统提供了一个简单、单一的屏障，客户通过这个屏障来与子系统进行通信。通过使用外观模式，使得客户对子系统的引用变得简单了，实现了客户与子系统之间的松耦合。但是它违背了“开闭原则”，因为增加新的子系统可能需要修改外观类或客户端的源代码。

![619330b276ee2e06114ed9853f807be2.png][]

外观模式包含如下角色：  
Facade: 外观角色  
SubSystem:子系统角色

11.亨元模式

在一个系统中对象会使得内存占用过多，特别是那些大量重复的对象，这就是对系统资源的极大浪费。享元模式对对象的重用提供了一种解决方案，它使用共享技术对相同或者相似对象实现重用。享元模式就是运行共享技术有效地支持大量细粒度对象的复用。系统使用少量对象,而且这些都比较相似，状态变化小，可以实现对象的多次复用。这里有一点要注意：享元模式要求能够共享的对象必须是细粒度对象。享元模式通过共享技术使得系统中的对象个数大大减少了，同时享元模式使用了内部状态和外部状态，同时外部状态相对独立，不会影响到内部状态，所以享元模式能够使得享元对象在不同的环境下被共享。同时正是分为了内部状态和外部状态，享元模式会使得系统变得更加复杂，同时也会导致读取外部状态所消耗的时间过长。

![5623b34d546d97f9933b4b88d1d16458.png][]

享元模式包含如下角色：  
Flyweight: 抽象享元类  
ConcreteFlyweight: 具体享元类  
UnsharedConcreteFlyweight: 非共享具体享元类  
FlyweightFactory: 享元工厂类

12.代理模式

代理模式就是给一个对象提供一个代理，并由代理对象控制对原对象的引用。它使得客户不能直接与真正的目标对象通信。代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。

代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的，同时也在一定程度上面减少了系统的耦合度。

![a60b697e2ba62399949aef0af9382494.png][]

代理模式包含如下角色：  
 Subject: 抽象主题角色  
 Proxy: 代理主题角色  
 RealSubject: 真实主题角色

13.访问者模式

访问者模式俗称23大设计模式中最难的一个。除了结构复杂外，理解也比较难。在我们软件开发中我们可能会对同一个对象有不同的处理，如果我们都做分别的处理，将会产生灾难性的错误。对于这种问题，访问者模式提供了比较好的解决方案。访问者模式即表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式。同时我们还需要明确一点那就是访问者模式是适用于那些数据结构比较稳定的，因为他是将数据的操作与数据结构进行分离了，如果某个系统的数据结构相对稳定，但是操作算法易于变化的话，就比较适用适用访问者模式，因为访问者模式使得算法操作的增加变得比较简单了。

![9ea2cc4aceef7ae8fd0df8959af36085.png][]

访问者模式包含如下角色：  
Vistor: 抽象访问者  
ConcreteVisitor: 具体访问者  
Element: 抽象元素  
ConcreteElement: 具体元素   
ObjectStructure: 对象结构

14.模板模式

有些时候我们做某几件事情的步骤都差不多，仅有那么一小点的不同，在软件开发的世界里同样如此，如果我们都将这些步骤都一一做的话，费时费力不讨好。所以我们可以将这些步骤分解、封装起来，然后利用继承的方式来继承即可，当然不同的可以自己重写实现嘛！这就是模板方法模式提供的解决方案。

所谓模板方法模式就是在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

模板方法模式就是基于继承的代码复用技术的。在模板方法模式中，我们可以将相同部分的代码放在父类中，而将不同的代码放入不同的子类中。也就是说我们需要声明一个抽象的父类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法让子类来实现剩余的逻辑，不同的子类可以以不同的方式来实现这些逻辑。所以模板方法的模板其实就是一个普通的方法，只不过这个方法是将算法实现的步骤封装起来的。

![945e29fb2c3a7de662774a95bb3ba348.png][]

模板方法模式包含如下角色：  
AbstractClass: 抽象类   
ConcreteClass: 具体子类

15.策略模式

我们知道一件事可能会有很多种方式来实现它，但是其中总有一种最高效的方式，在软件开发的世界里面同样如此，我们也有很多中方法来实现一个功能，但是我们需要一种简单、高效的方式来实现它，使得系统能够非常灵活，这就是策略模式。

所以策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式然该算法的变化独立于使用算法的客户。

在策略模式中它将这些解决问题的方法定义成一个算法群，每一个方法都对应着一个具体的算法，这里的一个算法我就称之为一个策略。虽然策略模式定义了算法，但是它并不提供算法的选择，即什么算法对于什么问题最合适这是策略模式所不关心的，所以对于策略的选择还是要客户端来做。客户必须要清楚的知道每个算法之间的区别和在什么时候什么地方使用什么策略是最合适的，这样就增加客户端的负担。

同时策略模式也非常完美的符合了“开闭原则”，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。但是一个策略对应一个类将会是系统产生很多的策略类。

![1c3c98ac9d5f11a8405132f7949ed6a7.png][]

策略模式包含如下角色：  
Context: 环境类  
Strategy: 抽象策略类  
ConcreteStrategy: 具体策略类

16.状态模式

在很多情况下我们对象的行为依赖于它的一个或者多个变化的属性，这些可变的属性我们称之为状态，也就是说行为依赖状态，即当该对象因为在外部的互动而导致他的状态发生变化，从而它的行为也会做出相应的变化。对于这种情况，我们是不能用行为来控制状态的变化，而应该站在状态的角度来思考行为，即是什么状态就要做出什么样的行为。这个就是状态模式。

所以状态模式就是允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。

在状态模式中我们可以减少大块的if…else语句，它是允许态转换逻辑与状态对象合成一体，但是减少if…else语句的代价就是会换来大量的类，所以状态模式势必会增加系统中类或者对象的个数。

同时状态模式是将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。但是这样就会导致系统的结构和实现都会比较复杂，如果使用不当就会导致程序的结构和代码混乱，不利于维护。

![e36d20ec87be5ad669bdfb1b76986684.png][]

状态模式包含如下角色：  
Context: 环境类  
State: 抽象状态类  
ConcreteState: 具体状态类

17.观察者模式

何谓观察者模式？观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。

在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以么可以根据需要增加和删除观察者，使得系统更易于扩展。所以观察者提供了一种对象设计，让主题和观察者之间以松耦合的方式结合。

![a0eb3c8568a37bad876fc50afe31580a.png][]

观察者模式包含如下角色：  
Subject: 目标  
ConcreteSubject: 具体目标  
Observer: 观察者  
ConcreteObserver: 具体观察者

18.备忘录模式

后悔药人人都想要，但是事实却是残酷的，根本就没有后悔药可买，但是也不仅如此，在软件的世界里就有后悔药！备忘录模式就是一种后悔药，它给我们的软件提供后悔药的机制，通过它可以使系统恢复到某一特定的历史状态。

所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。它实现了对信息的封装，使得客户不需要关心状态保存的细节。保存就要消耗资源，所以备忘录模式的缺点就在于消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

![da87ded0df74f7736fdf1f3749bd2138.png][]

备忘录模式包含如下角色：  
Originator: 原发器  
Memento: 备忘录  
Caretaker: 负责人

19.中介者模式

租房各位都有过的经历吧！在这个过程中中介结构扮演着很重要的角色，它在这里起到一个中间者的作用，给我们和房主互相传递信息。在外面软件的世界里同样需要这样一个中间者。在我们的系统中有时候会存在着对象与对象之间存在着很强、复杂的关联关系，如果让他们之间有直接的联系的话，必定会导致整个系统变得非常复杂，而且可扩展性很差！在前面我们就知道如果两个类之间没有不必彼此通信，我们就不应该让他们有直接的关联关系，如果实在是需要通信的话，我们可以通过第三者来转发他们的请求。同样，这里我们利用中介者来解决这个问题。

所谓中介者模式就是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。在中介者模式中，中介对象用来封装对象之间的关系，各个对象可以不需要知道具体的信息通过中介者对象就可以实现相互通信。它减少了对象之间的互相关系，提供了系统可复用性，简化了系统的结构。

在中介者模式中，各个对象不需要互相知道了解，他们只需要知道中介者对象即可，但是中介者对象就必须要知道所有的对象和他们之间的关联关系，正是因为这样就导致了中介者对象的结构过于复杂，承担了过多的职责，同时它也是整个系统的核心所在，它有问题将会导致整个系统的问题。所以如果在系统的设计过程中如果出现“多对多”的复杂关系群时，千万别急着使用中介者模式，而是要仔细思考是不是您设计的系统存在问题。

![8b5f917654984c30800c90e655dcdca2.png][]

Mediator: 抽象中介者  
ConcreteMediator: 具体中介者  
Colleague: 抽象同事类  
ConcreteColleague: 具体同事类

20.迭代器模式

对于迭代在编程过程中我们经常用到，能够游走于聚合内的每一个元素，同时还可以提供多种不同的遍历方式，这就是迭代器模式的设计动机。在我们实际的开发过程中，我们可能会需要根据不同的需求以不同的方式来遍历整个对象，但是我们又不希望在聚合对象的抽象接口中充斥着各种不同的遍历操作，于是我们就希望有某个东西能够以多种不同的方式来遍历一个聚合对象，这时迭代器模式出现了。

何为迭代器模式？所谓迭代器模式就是提供一种方法顺序访问一个聚合对象中的各个元素，而不是暴露其内部的表示。迭代器模式是将迭代元素的责任交给迭代器，而不是聚合对象，我们甚至在不需要知道该聚合对象的内部结构就可以实现该聚合对象的迭代。

通过迭代器模式，使得聚合对象的结构更加简单，它不需要关注它元素的遍历，只需要专注它应该专注的事情，这样就更加符合单一职责原则了。

![ec313a1b2d48cfa917d81fd4e2206223.png][]

迭代器模式包含如下角色：  
Iterator: 抽象迭代器  
ConcreteIterator: 具体迭代器  
Aggregate: 抽象聚合类  
ConcreteAggregate: 具体聚合类

21.解释器模式

所谓解释器模式就是定义语言的文法，并且建立一个解释器来解释该语言中的句子。解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。

![964ef8c276afbddd6e5932a72ecbe1de.png][]

解释器模式包含如下角色：  
AbstractExpression: 抽象表达式  
TerminalExpression: 终结符表达式  
NonterminalExpression: 非终结符表达式  
Context: 环境类  
Client: 客户类

22.命令模式

有些时候我们想某个对象发送一个请求，但是我们并不知道该请求的具体接收者是谁，具体的处理过程是如何的，们只知道在程序运行中指定具体的请求接收者即可，对于这样将请求封装成对象的我们称之为命令模式。所以命令模式将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。同时命令模式支持可撤销的操作。

命令模式可以将请求的发送者和接收者之间实现完全的解耦，发送者和接收者之间没有直接的联系，发送者只需要知道如何发送请求命令即可，其余的可以一概不管，甚至命令是否成功都无需关心。同时我们可以非常方便的增加新的命令，但是可能就是因为方便和对请求的封装就会导致系统中会存在过多的具体命令类。

![966b2bf8123cba49d7e18645ba620149.png][]

命令模式包含如下角色：  
Command: 抽象命令类  
ConcreteCommand: 具体命令类  
Invoker: 调用者  
Receiver: 接收者  
Client:客户类

23.责任链模式

职责链模式描述的请求如何沿着对象所组成的链来传递的。它将对象组成一条链，发送者将请求发给链的第一个接收者，并且沿着这条链传递，直到有一个对象来处理它或者直到最后也没有对象处理而留在链末尾端。

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止，这就是职责链模式。在职责链模式中，使得每一个对象都有可能来处理请求，从而实现了请求的发送者和接收者之间的解耦。同时职责链模式简化了对象的结构，它使得每个对象都只需要引用它的后继者即可，而不必了解整条链，这样既提高了系统的灵活性也使得增加新的请求处理类也比较方便。但是在职责链中我们不能保证所有的请求都能够被处理，而且不利于观察运行时特征。

![750546fa8d6d371edda8bb5d40e93b4a.png][]

职责链模式包含如下角色：  
Handler: 抽象处理者  
ConcreteHandler: 具体处理者  
Client: 客户类

**五、如何学习设计模式                                                                                                                          **

**说明，《如何学习设计模式》转摘自：http://blog.csdn.net/yqj2065/article/details/39103857**

### ①    学习技巧 ###

学习设计模式时，有一些技巧能够帮助你快速理解设计模式。

a)   使用较简单的**面向对象的语言**如Java、C\#。GoF的\[设计模式\]实质上是**面向对象的设计模式**。\[GoF·1.1\]中提到“程序设计语言的选择非常重要，它将影响人们理解问题的出发点”。从学习设计模式的角度看，Java和C\#较C++更容易一些。比如Java接口等，能够更有效展现设计模式的意图。

b)   使用**工具BlueJ**。BlueJ最大的好处，就是提供了简单的类图。正如我在[简明设计模式Java][Java]中所做的，较少去专门画类图，而是在BlueJ中截图。在学生上机编写演示程序时，常常先看他的类图，以判断他的程序是否正确，必要时再看源代码。

c)   日常生活的**隐喻**。用一些实际生活中的例子来说明某某模式，能够让你快速掌握某模式的目的和实现代码的结构。同时，你要认识到，这种隐喻如同告诉你（2+3）2=22+2\*2\*3+32，你需要自己举一反三，得出（a+b）2=a2+2ab+b2。在实际工作中的模式的具体应用，则相当于应用代数公式。

d)    **动手实践和怀疑精神**。看**显浅的参考书或上网查阅资料**时，要自己敲(复制也可以)代码并运行，要多修改别人的源代码提出自己的观点：为什么书中不这样设计、为什么要那样设计；如果增添一些方法、方法参数、或成员变量会如何？必须要自己亲自动手，最起码要运行。另外，要敢于向博主提问、拍砖。你甚至可以质疑GoF的某些章节的解说和意图，更何况一些博主呢。

### ②    基础知识 ###

这些知识让你知道，设计模式好在何处。

a)    **面向对象范式**。也就是人们传说的思想。封装、继承和多态这些东西，在我看来比if、for等稍微高一点，也属于语法问题。面向对象编程要掌握的[三大原则][Link 1]是**柏拉图(Plato)原则、里氏(Liskov)替换原则和Parnas原则**。这三个原则其实非常简单。任何原则，你觉得很难一见钟情，很难快速认同，那它就不会是好原则。

b)    **设计原则。**许多人列举了7大原则，如单一职责原则、开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、合成复用原则、迪米特法则。LSP，我将它提升为面向对象范式的3大基石之一；单一职责和接口隔离，主要作为面向对象分析/OOA时职责划分所遵循的原则，此时你可以不太在意。依赖倒转原则，我把它作为垃圾扔掉，因为**开闭原则或者直接地说“依赖于抽象类型原则”**已经包含了依赖倒转原则的精华，而依赖倒转原则的糟粕由IoC继承。当然，[回调][Link 2]，我很强调。所以，你要掌握的有**抽象依赖原则(OCP)、单向依赖原则(含对回调的学习)和最低依赖原则(合成复用原则、迪米特法则)**。

c)    UML的初步了解。这是学习设计模式的工具。在早期，你甚至可以仅了解BlueJ的相关图示，也就10分钟的事情。

### ③    境界 ###

《五灯会元》卷十七中，有一则唐朝禅师青原惟信禅师的语录:“老僧三十年前未参禅时，见山是山，见水是水。及至后来亲见知识，有个入处，见山不是山，见水不是水。而今得个休歇处，依前见山只是山，见水只是水。”

a)    仔细研究GoF的\[设计模式\]，逐个学习其**意图和结构**，是一个抱着字典学习英语的方式。见山是山，见水是水，导致你可能在实际工作中生搬硬套、东施效颦。

b)    建议从简单的场景出发，**自己发现或设计出某种模式**。你从中体会该模式是如何解决问题的，这样，该模式成为你自己的东西，你才不会出现**知易行难**的问题。所有的设计模式不过是基本原则和理念在特定场合的应用。你可能不知道某个设计模式的名字，但是你知道它一切的优缺点和变体以及应用场合。见山不是山，见水不是水。

c)     你对**基本原则和理念**融会贯通，你可以惋惜：“我找到一种模式，原来在\[设计模式\](其实是某个特殊的书、文章提到的模式)中早就有了这种模式”。这时，模式不模式又如何呢？反模式又怎样。看见一个模式，你会说：“嗯，这是一种有用的模式”。见山只是山，见水只是水。

以上一点浅见。

--------------------

注：【】中的内容是我加的。

1 转录【IT168知识库】

发现很多初学设计模式的人都有一些特点就是学习了某个设计模式之后，**貌似理解了，但是却不知道怎么去使用**这些所谓的精华经验，苦于不知如何下手。我最初学习设计模式的时候也有类似的经验，我将我的经验分享出来，希望能对初学者有帮助。  
        我对设计模式产生兴趣是在大概一年以前，最初看书的时候好像是看懂了，大概知道他在说什么。看了几个模式之后就开始寻找时机来套用套用这些模式。结果是除了Singleton模式以外的其他模式都没有找到应用的场所。然后我就没开始看下去了，我知道再看也没用，但是我并没有放弃对设计模式的关注。  
        不久我就在MSDN的Webcast上看到李建忠的 C\#面向对象设计模式纵横谈讲座，很不错的系列讲座，让我对设计模式有了新的理解。我**意识到学习设计模式，确切的讲是学习面向对象的设计模式，应该从学习面向对象开始**。【**面向对象的原理如同了解下象棋的规则，而设计模式相当于残局，不知道规则看什么残局**】由于之前一年都在做asp.net开发，虽然都是在写类、学着duwamish搞分层架构、搞类型化DataSet、也弄过自定义实体类，但好像一年下来还没怎么用过接口，什么多态也是极少用。事实上对面向对象的编程思想的认识还是很模糊的。  
        重新认识OO：面向对象编程是一种思想，以面向对象的思维来思考软件设计结构，从而强化面向对象的编程范式。面向对象的特点是封装，继承，多态【**这些也算？**】。所以从那是开始，当我设计一个类的时候，不断的提示自己以下三点：  
第一：别把自己的数据公开，除非你要向别人提供数据，使用尽量低的访问权限。  
第二：以一个外部的视角来看类，紧记不要要求别人要在知道你是怎么实现一个方法之后才能使用我的类。  
第三：分清类的职责，该这个类做的事情就要在这个类中实现，不该我的类做的事情就让别的类去实现。  
在这三点的指导下来写类，写程序开始像在做“设计”了^\_^。  
一段时间后对设计模式就慢慢有感觉了，并能够找到一些设计模式的应用场景了。并常套用套用那些模式，逐渐的加深对模式的理解，并把它变成自己的东西，能够在其他的地方灵活的用起来。

2. 转录 《易学设计模式·1.4  如何学习设计模式》郭志学 人民邮电出版社

如何学习设计模式  
在了解了设计模式的历史和分类后，应该如何学习设计模式呢？在学习设计模式之前，读者一定要树立一种意识，那就是：**设计模式并不只是一种方法和技术，它更是一种思想、一个方法论。**它和具体的语言没有关系，学习设计模式**最主要的目的就是要建立**面向对象的思想，尽可能地面向接口编程、低耦合、高内聚，使你设计的程序尽可能地复用。【**似是而非。学习设计模式能够更好理解面向对象的思想，设计模式是一些设计的技巧和窍门，不要上升到思想、方法论好不好**】  
有些软件开发人员，在程序设计时，总想着往某个设计模式上套，其实这样是不对的，并没有真正掌握设计模式的思想。其实很多时候读者用了某种设计模式，只是自己不知道这个模式叫什么名字而已。因此，在程序设计时，要根据自己的理解，使用合适的设计模式。  
而有另外一些软件开发人员，在程序设计时，动不动就给类起个类似模式的名字，比如叫某某Facade、某某Factory等，其实类里面的内容和设计模式根本没有一点关系，只是用来标榜自己懂设计模式而已。  
因此，学习设计模式，首先要了解有哪些方面的设计模式可以供开发人员使用，然后再分别研究每个设计模式的原理，使用时机和方法，也就是说要在什么情况下才使用某个设计模式，在了解某个设计模式的使用时机时，还要了解此时如果不使用这个设计模式，会造成什么样的后果。当对每个模式的原理和使用方法都了解了**以后**，更重要的是，学习面向对象的思想方式，在掌握面向对象的思想方式后，再回过头来看设计模式，就会有更深刻的理解，**最后，学习设计模式，一定要勤学多练**。【就最后一句很赞同】

** **

**六、个人感悟                                                                                                                 **

学习设计模式确实有几种境界：

第一种是学习了一两个设计模式，就一直想用到自己的代码中去；

第二种是学完全部设计模式，觉得很多模式都很相似，分不清楚它们之间有什么区别；

第三种是灵活运用设计模式，就算不用具体哪种模式也可以设计也高质量的代码，无剑胜有剑。

最后附上总结图：

![4c9b89ff6b93f2939853a5ee347587db.png][]

[043c778173f5d7a1ca8b92261bc4036b.png]: /images/20221123/60bb32837c6b49edafe15b8cce6489c5.png
[2cead0e26750b69c5c194259d45b35a2.png]: /images/20221123/81e1b7c6923e4a93928360570a7483db.png
[fe259853ed3a706b7d9252b12d880a59.png]: /images/20221123/53a05df9400d459c8722bbb248e1c8ff.png
[d2490c2978f74ab93a0475851d372f69.png]: /images/20221123/8de611bd88094895b1139d50f062393b.png
[3bca3a51b180ea87a1f034d1b0f07369.png]: /images/20221123/388fff762c2042b49d39064b1d0d7334.png
[770c140eae6bd1725a6219aed557e7fe.png]: /images/20221123/bbca7dcadbe64e59b04305fbbab07bc8.png
[30b7387c19ec7c98188981d3fe9002a8.png]: /images/20221123/3278a2154a014c9d99503b705a6a1e7f.png
[3914047275463f513921ae9f79bc6799.png]: /images/20221123/dcef8acf3df745d1a1a084b9936c1dee.png
[bf858398addf08eae799a20a9a3c2a7e.png]: /images/20221123/dfde3f83ee67404d82e7d8a223192558.png
[0bde191d8ba06f44e57ee4860288abed.png]: /images/20221123/bcc7d0f2a3c2441c9081974240369d4b.png
[619330b276ee2e06114ed9853f807be2.png]: /images/20221123/48057c02958946c38bd9ebb3d96152e6.png
[5623b34d546d97f9933b4b88d1d16458.png]: /images/20221123/efb5878b589345f69fcaefbfc73b52aa.png
[a60b697e2ba62399949aef0af9382494.png]: /images/20221123/c4f24fd41f4b4882801049f7ae0516b1.png
[9ea2cc4aceef7ae8fd0df8959af36085.png]: /images/20221123/35f36663d3444c3497d5742881efb87f.png
[945e29fb2c3a7de662774a95bb3ba348.png]: /images/20221123/4c8d595bf4f44c30be07620aa4378160.png
[1c3c98ac9d5f11a8405132f7949ed6a7.png]: /images/20221123/48ae771308f046eea0a3fe1139ba1a19.png
[e36d20ec87be5ad669bdfb1b76986684.png]: /images/20221123/308bd235867b4803906cbddf42a0a714.png
[a0eb3c8568a37bad876fc50afe31580a.png]: /images/20221123/c625106fe076487392fdc6a601a856db.png
[da87ded0df74f7736fdf1f3749bd2138.png]: /images/20221123/3393bda93a2d4c7ca965f07442968b88.png
[8b5f917654984c30800c90e655dcdca2.png]: /images/20221123/e961aa31a0f343adb165818a54cd1dac.png
[ec313a1b2d48cfa917d81fd4e2206223.png]: /images/20221123/d0715b47af9a49dca4f6ab0e3bea199e.png
[964ef8c276afbddd6e5932a72ecbe1de.png]: /images/20221123/30bfb804676a4a2fb56f421ddf3f39f9.png
[966b2bf8123cba49d7e18645ba620149.png]: /images/20221123/1b998815b58147609007e56d2594dc9b.png
[750546fa8d6d371edda8bb5d40e93b4a.png]: /images/20221123/d60ee376f85543558c2314eb873920b9.png
[Java]: http://blog.csdn.net/column/details/dp-in-java-yqj2065.html
[Link 1]: http://blog.csdn.net/yqj2065/article/details/8502681
[Link 2]: http://blog.csdn.net/yqj2065/article/details/8758101
[4c9b89ff6b93f2939853a5ee347587db.png]: /images/20221123/dfae78217d7e4376bd1a6bd0f6b25d8c.png