北风设计模式课程---创建型模式总结

逃离我推掉我的手 2021-11-05 01:54 361阅读 0赞

# 北风设计模式课程---创建型模式总结 #

## 一、总结 ##

### 一句话总结： ###

##### 创建型模式就是 生产对象 的模式。 #####

### 1、建造者模式是什么？ ###

##### 施工队+设计师来造房子的情况：不同的施工队造不同的房子，统一由设计师指导 #####

### 2、创建型设计模式 分类？ ###

##### 工厂：简单工厂，工厂方法，抽象工厂 #####

##### 性能（实例份数）：单例模式，原型模式 #####

##### 复杂情况：建造者模式 #####

## 二、创建型模式总结 ##

转自或参考：创建型模式总结  
https://blog.csdn.net/lclcsdnblink/article/details/88656363

创建型模式有以下几个模式：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70][]

简单工厂 ： 用来生产同一等级结构中的任意产品。（不支持拓展增加产品）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）

抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

建造者模式：将建造人各个躯体的方法和躯体的具体数据分离开来，使得相同的方法，可以建立不同形态的人

原型模式：通过拷贝，可以将代码中的数据和具体实现复制过来，也可以将其中的数据修改

单例模式：将实例化的代码私有化，在公共方法中加以判断，符合条件的可以进行实例化，否则，不可以实例化。

创建者模式：隐藏了这些类的实例是如何被创建和放在一起，整个系统关于这些对象所知道的是由抽象类所定义的接口。这样，创建型模式在创建了什么，谁创建它，它是怎么被创建的，以及何时创建这些方面提供了很大的灵活性。

工厂方法：

概念：如果在主程序中调用工厂类中的加法，那么实例化加法类，也就是说定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

优点：在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 1][]

static void Main(string[] args)
            {
                IFactory operFactory = new AddFactory();     //在客户端调用加法，让客户端来判断
                Operation oper = operFactory.CreateOperation();
                oper.NumberA = 1;
                oper.NumberB = 2;
                double result = oper.GetResult();
            }

具体的应用：[http://www.runoob.com/design-pattern/factory-pattern.html][http_www.runoob.com_design-pattern_factory-pattern.html]

抽象工厂

概念：抽象工厂是应对产品族概念的。上边的工厂方法模式是一种极端情况的抽象工厂模式（即只生产一种产品的抽象工厂模式），而抽象工厂模式可以看成是工厂方法模式的一种推广。

优点：

**1.**当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

2.在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 2][]

3.它让具体的创建实例过程与客户端分离，客户端是通多她们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端代码中。

![2019031911491399.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 3][]

具体应用：[http://www.runoob.com/design-pattern/abstract-factory-pattern.html][http_www.runoob.com_design-pattern_abstract-factory-pattern.html]

建造者模式：

概念：

1.将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2.用户就只需指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不需知道了。

何时时候使用：

1。用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

2.是在当常见复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。

优点：使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以如需要改变一个产品的内部表示，只需要在定义一个具体的建造者就可以了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 4][]

具体应用：[http://www.runoob.com/design-pattern/builder-pattern.html][http_www.runoob.com_design-pattern_builder-pattern.html]

原型模式：

概念：

1.用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

2.从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节。（系统自带的方法）

例子：细胞分裂

Resume a = new Resume("大鸟");
                a.SetPersonalInfo("男", "29");  //向简历的方法中的参数添加相应的值
                a.SetWorkExperience("1998-2000", "XX公司");
    
                Resume b = (Resume)a.Clone();    //复制a中的参数和值
                b.SetWorkExperience("1998-2006", "YY企业");  //修改相应的参数中的值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 5][]

**浅复制：**将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

**深复制：**将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

具体应用：[http://www.runoob.com/design-pattern/prototype-pattern.html][http_www.runoob.com_design-pattern_prototype-pattern.html]

单例模式：

概念：

1.保证一个类仅有一个实例，并提供一个访问它的全局访问点

①

private static FormToolbox ftb = null;  //系统自带
            private FormToolbox()            //系统自带，把public改为private，就不可以让外界实例化了（保证一个类仅有一个实例）
            {
                InitializeComponent();
            }
    
             public static FormToolbox GetInstance()  //外界想要实例化需要通过下面的条件，才可以实例化（提供一个访问它的全局访问点）
             { 
                 if (ftb == null || ftb.IsDisposed)
                 {
                     ftb = new FormToolbox();
                     ftb.MdiParent = Form1.ActiveForm;
                    //在这个方法里面写show也能show出来
                    ftb.Show();
                 }
                 return ftb;
             }

②

//将下面类的构造函数private，将外界利用new创建此类实例的可能堵死
    class Singleton
        {
            private static Singleton instance;  //私有Singleton类的对象instance
            //为了改变访问修饰符
            private Singleton()                  ///私有构造函数
            { } 
            public static Singleton GetInstance()  //当外界访问这个方法的时候，只有符合条件，才能在这个类中实例化这个类
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
    
        }

饿汉式单例类：静态初化

private static readonly object syncRoot = new object();  //在加载时就将自己实例化

懒汉式单例类：第一次被引用时，才会将自己实例化（new）

ObjectStructure o = new ObjectStructure();

多线程的单例和双重锁定

具体应用：[http://www.runoob.com/design-pattern/singleton-pattern.html][http_www.runoob.com_design-pattern_singleton-pattern.html]

## 三、创建型模式总结 ##

转自或参考：创建型模式总结  
https://www.cnblogs.com/yuyu666/p/9743740.html

创建类模式主要关注对象的创建过程，将对象的创建过程进行封装，使客户端可以直接得到对象，而不用去关心如何创建对象。创建类模式有5种，分别是：

单例模式：用于得到内存中的唯一对象。

工厂方法模式：用于创建复杂对象。

抽象工厂模式：用于创建一组相关或相互依赖的复杂对象。

建造者模式：用于创建模块化的更加复杂的对象。

原型模式：用于得到一个对象的拷贝。

为什么需要创建性模式：

首先，在编程中，对象的创建通常是一件比较复杂的事，因为，为了达到降低耦合的目的，我们通常采用面向抽象编程的方式，对象间的关系不会硬编码到类中，而是等到调用的时候再进行组装，这样虽然降低了对象间的耦合，提高了对象复用的可能，但在一定程度上将组装类的任务都交给了最终调用的客户端程序，大大增加了客户端程序的复杂度。采用创建类模式的优点之一就是将组装对象的过程封装到一个单独的类中，这样，既不会增加对象间的耦合，又可以最大限度的减小客户端的负担。

其次，使用普通的方式创建对象，一般都是返回一个具体的对象，即所谓的面向实现编程，这与设计模式原则是相违背的。采用创建类模式则可以实现面向抽象编程。客户端要求的只是一个抽象的类型，具体返回什么样的对象，由创建者来决定。

再次，可以对创建对象的过程进行优化，客户端关注的只是得到对象，对对象的创建过程则不关心，因此，创建者可以对创建的过程进行优化，例如在特定条件下，如果使用单例模式或者是使用原型模式，都可以优化系统的性能。

总结：

所有的创建类模式本质上都是对对象的创建过程进行封装。

转载于:https://www.cnblogs.com/Renyi-Fan/p/11094551.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70]: /images/20211104/4e06b0172b444a16adff3b507b72a1ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 1]: /images/20211104/225fe5753c644ea3a2915e95e3221e0e.png
[http_www.runoob.com_design-pattern_factory-pattern.html]: http://www.runoob.com/design-pattern/factory-pattern.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 2]: /images/20211104/d150911a5f0045ab926f03238e38715e.png
[2019031911491399.png]: /images/20211104/51b19377df3a47a1b5f081cb17657368.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 3]: /images/20211104/628ea14610744c619af9ff37f227c38b.png
[http_www.runoob.com_design-pattern_abstract-factory-pattern.html]: http://www.runoob.com/design-pattern/abstract-factory-pattern.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 4]: /images/20211104/1f734879c9964f30bb4fd6f86319e65c.png
[http_www.runoob.com_design-pattern_builder-pattern.html]: http://www.runoob.com/design-pattern/builder-pattern.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjbGNzZG5ibGluaw_size_16_color_FFFFFF_t_70 5]: /images/20211104/5f49ed03d75840d9a92bd8b3288474ca.png
[http_www.runoob.com_design-pattern_prototype-pattern.html]: http://www.runoob.com/design-pattern/prototype-pattern.html
[http_www.runoob.com_design-pattern_singleton-pattern.html]: http://www.runoob.com/design-pattern/singleton-pattern.html