目录

创建型模式

抽象工厂模式

建造者模式

工厂方法模式

原型模式

单例模式

---

创建型模式

        创建型模式使设计变得更灵活，提供了不同的方式，从代码中移除了对需要实例化的具体类的引用。换句话说，这些模式增强了对象和类之间的独立性。

设计模式名称	简要说明
抽象工厂模式 (Abstract Factory)	提供一个接口,可以创建一系列相关或相互依赖对象，而无需指定它们具体的类。
建造者模式 (Builder)	将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
工厂方法模式 (Factory Method)	定义一个用于创建对象的接口，让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。
原型模式 (Prototype)	用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
单例模式 (Singleton)	保证一个类仅有一个实例，并提供一个访问它的全局访问点。

抽象工厂模式

1、概述：

        抽象工厂（AbstractFactory）模式：为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

        抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

2、主要角色：

        ①、抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。

        ②、具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

        ③、抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

        ④、具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

3、应用场景：

        ①、一个系统要独立于它的产品的创建、组合和表示时；

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

        ③、需要强调一系列相关的产品对象的设计以便进行联合使用时；

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

4、优点：

        ①、分离了具体的类。客户通过抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中。

        ②、易于交换产品系列。一个具体工厂类只在初始化时出现一次，这使得改变一个应用的具体工厂变得很容易，只需改变具体的工厂即可使用不同的产品配置。

        ③、有利于产品的一致性。当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要，而抽象工厂很容易实现这一点。

5、缺点：

        ①、难以支持新种类的产品。因为抽象工厂接口确定了可以被创建的产品集合，所以难以扩展抽象工厂以生产新种类的产品。

建造者模式

1、概述：

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

        建造者模式的核心在于如何一步步构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品，在软件开发中，如果我们需要创建复杂对象并希望系统具备很好的灵活性和可扩展性可以考虑使用建造者模式。

2、主要角色：

        ①、Builder（抽象建造者）：为创建一个产品对象的各个部件指定抽象接口。

        ②、ConcreteBuilder（具体建造者）：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

        ③、Director（指挥者）：构造一个使用Builder接口的对象，。

        ④、Product（产品角色）：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

3、应用场景

        ①、需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。

        ②、需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

        ③、对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在构建器类和客户类中。

        ④、隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

4、优点

        ①、在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

        ②、每一个具体构建器都相对独立，而与其他的具体构建器无关，因此可以很方便地替换具体构建器或增加新的具体构建器，用户使用不同的具体构建器即可得到不同的产品对象。由于指挥者类针对抽象构建器编程，增加新的具体构建器无须修改原有类库的代码，系统扩展方便，符合“开闭原则”

        ③、可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

5、缺点

        ①、建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，例如很多组成部分都不相同，不适合使用建造者模式，因此其使用范围受到一定的限制。

        ②、如果产品的内部变化复杂，可能会导致需要定义很多具体构建器类来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本。

工厂方法模式

1、概述：

        工厂方法模式(Factory Method Pattern)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化，工厂方法模式让一个类的实例化延迟到其子类。此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。

        我们不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构

2、主要角色：

        ①、抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

        ②、具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

        ③、抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

        ④、具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

3、应用场景

         ①、客户端不知道它所需要的对象的类。在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建，可将具体工厂类的类名存储在配置文件或数据库中。

        ②、抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

4、优点

        ①、在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。

        ②、基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，就正是因为所有的具体工厂类都具有同一抽象父类。

        ③、使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。

5、缺点

        ①、在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。

        ②、由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

原型模式

1、概述：

        原型模式(Prototype Pattern)：使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式是一种对象创建型模式。

        原型模式的工作原理很简单：将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝自己来实现创建过程。由于在软件系统中我们经常会遇到需要创建多个相同或者相似对象的情况，因此原型模式在真实开发中的使用频率还是非常高的。原型模式是一种“另类”的创建型模式，创建克隆对象的工厂就是原型类自身，工厂方法由克隆方法来实现。

2、主要角色：

        ①、Prototype（抽象原型类）：它是声明克隆方法的接口，是所有具体原型类的公共父类，可以是抽象类也可以是接口，甚至还可以是具体实现类。

        ②、ConcretePrototype（具体原型类）：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。

        ③、Client（客户类）：让一个原型对象克隆自身从而创建一个新的对象，在客户类中只需要直接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到多个相同的对象。

3、应用场景

        ①、创建新对象成本较大（如初始化需要占用较长的时间，占用太多的CPU资源或网络资源），新的对象可以通过原型模式对已有对象进行复制来获得，如果是相似对象，则可以对其成员变量稍作修改。

        ②、如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占用内存较少时，可以使用原型模式配合备忘录模式来实现。

        ③、需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。

4、优点

        ①、当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。

        ②、扩展性较好，由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编程，而将具体原型类写在配置文件中，增加或减少产品类对原有系统都没有任何影响。

        ③、原型模式提供了简化的创建结构，工厂方法模式常常需要有一个与产品类等级结构相同的工厂等级结构，而原型模式就不需要这样，原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品。

        ④、可以使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便在需要的时候使用（如恢复到某一历史状态），可辅助实现撤销操作。

5、缺点

        ①、需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进行改造时，需要修改源代码，违背了“开闭原则”。

        ②、在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦。

单例模式

1、概述：

        单例模式(Singleton Pattern)：一个类有且仅有一个实例，并且自行实例化向整个系统提供。

        单例模式有三个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

        具体实现角度来说就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

2、主要角色：

        Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以访问它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有；在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例。

3、应用场景

        ①、系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

        ②、客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

4、优点

        ①、单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。

        ②、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

        ③、允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题。

5、缺点

        ①、由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。

        ②、单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。

        ③、现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

设计模式之设计原则

设计模式之结构型模式

单例模式

1 创建型模式

本人理解：以C++为例，创建对象时，用关键字new来创建（实例化）对象。用一个函数或类将new的过程封装起来，就是创建型模式。

《设计模式》中的描述：
创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。
一个类----创建型模式使用继承改变被实例化的类，
一个对象-创建型模式将实例化委托给另一个对象。
（看后，一头雾水）

工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）

2 结构型模式

本人理解：创建型模式关注一个类或对象的实例化；结构型模式关注多个类或对象组合成更复杂的对象，是为了更灵活的构造对象。

《设计模式》中的描述：结构性模式涉及到如何组合类和对象以获得更大的结构。
结构型类----模式采用继承机制来组合接口和实现。
结构型对象-模式不是对接口和实现进行组合，而是描述了如何对一些对象进行组合，从而实现新功能的一些方法。
（看后，一头雾水）

适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
过滤器模式（Filter、Criteria Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）

3 行为型模式

本人理解：上述两种模式都是出于一定目的（复用代码、修改时更灵活、容易维护等等）创建对象，对象之间一通信，一个程序就跑起来啦，把对象之间通信这部分，再总结总结，起个名字，就叫“行为型模式”。

《设计模式》中的描述：行为模式涉及到算法和对象间职责的分配。
行为模式不仅描述对象和类的模式，还描述它们之间的通信模式。
行为模式使用继承机制在类间分派行为。（还是一头雾水）

责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）

各个模式之间的关系图

参见《设计模式》第8页

设计模式的六大原则

1、开闭原则（Open Close Principle）

本人理解：增加新功能时，重新定义一个接口（开），不要修改原来的接口（闭）（为了向下兼容，如果修改了，可能对已经使用这个接口的代码造成影响）。

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）
本人理解：子类包括基类的全部功能。

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承

说明：文末可下载案例源码                                

                                             创建型（为类实例化提供指南）

原型模式	原型模式（Prototype Pattern）是用于创建重复的对象，并且与重新new对象相比较，性能更高。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时。[详情...]
工厂方法	工厂方法（FactoryMethod）不在工厂类中进行逻辑判断，程序可以为不同产品类提供不同的工厂，不同的工厂类产不同的产品。当使用工厂方法设计模式时，对象调用者需要与具体的工厂类耦合。[详情...]
单例模式	单例模式（Singleton Pattern）涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。[详情...]
构造器模式	构造器模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。一个 Builder 类会一步一步构造最终的对象。该 Builder 类无需通过其他对象完成构造，独立于其他对象的。[详情...]
简单工厂模式	简单工厂模式（SimpleFactory Pattern）中，我们在创建对象时不会对客户端暴露创建逻辑，是由一个工厂对象决定创建出哪一种产品类的实例。它属于创建型模式，但不属于23种GOF设计模式之一。[详情...]
抽象工厂模式	抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。[详情...]

说明：文末可下载案例源码 

                             结构型（为类如何设计以形成更优秀的结构提供指南）

代理模式	在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。[详情...]
桥接模式	桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。[详情...]
外观模式	外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供一个客户端可以访问系统的接口。它向现有的系统添加一个接口，来隐藏系统的复杂性。[详情...]
装饰模式	装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。[详情...]
享元模式	享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。[详情...]
组合模式	组合模式（Composite Pattern），又叫部分整体模式，是用于把一复合对象（对象中引用其他对象）当作一个单一简单的对象。组合模式依据树形结构来组合对象。[详情...]
适配器模式	适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立模块的功能。这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。[详情...]

说明：文末可下载案例源码 

                       行为型（为类与对象交互以及之间职责分配方式提供指南）

命令模式	命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。[详情...]
策略模式	在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变。[详情...]
状态模式	在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。[详情...]
模板模式	在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。[详情...]
中介者模式	中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。[详情...]
解释器模式	解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。[详情...]
职责链模式	责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。在这种模式中，通常每个接收者都包含对另一个接收者的引用。[详情...]
访问者模式	在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者的不同而改变。[详情...]
迭代器模式	迭代器模式（Iterator Pattern）是用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。[详情...]
备忘录模式	备忘录模式（Memento Pattern）保存一个对象的某个状态。在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。[详情...]
观察者模式	当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。[详情...]

<<<24种设计模式实现案例源码下载>>>