设计模式创建型

原创已于 2023-05-15 19:39:33 修改 · 4.8k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#单例模式

于 2022-04-14 23:08:26 首次发布

设计模式专栏收录该内容

3 篇文章

订阅专栏

一：前言

最近在进行设计模式的学习，今天将创建型的设计模式总结在这里，区分不同的设计模式的用法和作用

二：五个模式

2.1 创建型模式是什么？

创建型设计模式是一类软件设计模式，它们提供了一种在创建对象时增强灵活性和重用性的方法。
这些模式隐藏了对象的创建过程，使客户端代码能够与创建过程分离，从而降低了耦合性并提高了可维护性。

2.2 创建型模式的构成

创建型设计模式包括、工厂方法模式、原型模式、抽象工厂模式、建（构）造者模式 单例模式和。每个模式都有不同的用途和特点，它们可以在不同的情况下用于创建对象，以满足不同的需求。
用一个顺口溜表示就是：
公园瞅单狗（工厂、原型、抽象工厂、单例、构造者），公园里瞅单身狗，给他找个对象。

三：五个模式以及代码实现

3.1 工厂方法模式

3.1.1 概念

工厂方法模式是一种创建型设计模式，它将对象的创建委托给子类来完成。它通过定义一个创建对象的接口，但是将具体对象的创建延迟到子类中进行。这样，客户端代码不需要知道创建哪个具体的对象，只需要知道使用哪个工厂来创建对象即可。

工厂方法模式包含以下几个要素：

一个抽象的工厂接口，定义了创建对象的方法。
一组具体的工厂类，实现了工厂接口，负责创建具体的对象。
一个抽象的产品接口，定义了产品的通用属性和方法。
一组具体的产品类，实现了产品接口，是工厂创建的具体对象。

客户端代码使用工厂方法模式来创建对象时，只需要使用抽象工厂接口来创建对象，而无需关心具体的产品实现。当需要创建不同类型的对象时，只需要添加相应的具体工厂和产品即可，而不需要修改客户端代码。

3.1.2 代码例子

 //抽象的工厂
    internal interface ICreator 
    {
        //返回一个产品
        IProduct FactoryMethod();
    }
    //抽象的产品
    interface IProduct
    {    
    }
    //具体的工厂
    class ConcreteCreator : ICreator
    {
        //创建的是一个具体的产品
        public IProduct FactoryMethod()
        {
            return new ConcreteProduct();
        }
    }
    //具体的产品
    class ConcreteProduct : IProduct
    { }

最后创建的是具体的产品。如果增加了新的需求的话，我们可以增加一个新的工厂，然后增加一个新的产品。客户端依赖的是抽象的产品和抽象的工厂

3.2 原型模式

3.2.1 概念

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。
原型模式包含以下主要角色：

抽象原型类：规定了具体原型对象必须实现的接口。
- 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

原型模式的克隆分为浅克隆和深克隆。

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

3.2.2 代码示例

    //抽象类
    abstract class Prototype
    {
        private string id;
        public Prototype(string id)
        {
            this.id = id;
        }
        public string Id
        { get { return this.id; } }

        public abstract Prototype Clone();
    }

    class ConcretePrototype1 : Prototype
    {
        public ConcretePrototype1(string id) : base(id)
        { }
        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }


    }

3.3 抽象工厂模式

3.3.1 抽象工厂模式

抽象工厂模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

也就是说和工厂方法相比，抽象工厂抽象的是各类工厂，具体工厂可以实现为多个工厂。抽象产品也有多个，并且每个抽象产品下面都可以实现多个具体的产品。

3.4 单例模式

3.4.1 基本概念：

单例模式是一种创建型设计模式，用于确保一个类只有一个实例，并提供全局访问点以访问该实例。这意味着无论在系统中的哪个位置调用该类的实例，都始终返回同一个实例。

单例模式通常在需要共享资源的情况下使用，例如数据库连接，日志记录器等。通过使用单例模式，可以避免不必要的对象创建和销毁，从而提高系统的性能和效率。

单例模式的实现通常包括以下几个要素：

私有的构造函数，防止类在外部被实例化。
私有的静态实例变量，用于保存该类的唯一实例。
公共的静态方法，用于返回该类的唯一实例。
需要注意的是，由于单例模式只允许一个实例，因此在多线程环境中需要进行同步处理，以确保线程安全。

3.4.2 代码示例

	internal class Single
    {
      	 private  static Single single;   //建立一个全局对象
        private Single()    //将构造函数进行隐藏，外部不可访问
        { }
        public  static Single GetSingle()
        {
            if (single ==null)  //如果第一次访问的话，就完成对象初始化
            {
                single = new Single();
            }
            return single;
        }
    }

3.4.3 要点

单例模式一共有三个要点。

某个类只能有一个实例；
它必须自行创建这个实例。
它必须向整个系统提供这个实例。

对应到代码上来说就是：私有构造函数、私有静态对象、共有创建获取的方法。

3.5（构）建造者模式

3.5.1 概念

建造者模式是一种创建型设计模式，它将一个复杂对象的构建过程分解成多个简单对象的构建过程，使得对象构建过程更加灵活和可控。

建造者模式包含以下几个要素：

一个抽象的建造者接口，定义了复杂对象的构建过程。
一组具体的建造者类，实现了建造者接口，负责构建复杂对象的各个部分。
一个指挥者类，它包含一个建造者对象，并使用建造者对象中的方法来构建对象。
一个产品类，它包含了要构建的复杂对象的各个部分。

客户端代码使用建造者模式来构建复杂对象时，只需要将建造者对象传递给指挥者对象，由指挥者对象来使用建造者对象中的方法构建对象。客户端代码不需要直接创建复杂对象，也不需要了解具体的构建过程，从而提高了代码的可维护性和可扩展性。

3.5.2 代码示例


    //产品
    class Product
    {
        //产品属性
        private string A;
        private string B;
        private string C;

        //给产品属性赋值的方法
        public void setPartA(string A)
        {
            this.A = A;
        }
        public void setPartB(string B)
        {
            this.B = B;
        }
        public void setPartC(string C)
        {
            this.C = C;
        }
    }
    //抽象的建造者
    abstract class Builder
    {
        //创建产品对象
        protected Product product = new Product();
        //产品对象的具体构造，父类定义了构造结构，子类具体构造
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract void BuildPartC();
        //获得产品对象
        public Product GetProduct() { 
            return product;
        }
    }
    //具体建造者
    class ConcreteBuilder1 : Builder
    {
        public override void BuildPartA()
        {
            product.setPartA("属性1A");
        }

        public override void BuildPartB()
        {
            product.setPartB("属性1B");
        }

        public override void BuildPartC()
        {
            product.setPartC("属性1C");
        }
    }
    //具体建造者2
    class ConcreteBuilder2 : Builder
    {
        public override void BuildPartA()
        {
            product.setPartA("属性2A");
        }

        public override void BuildPartB()
        {
            product.setPartB("属性2B");
        }

        public override void BuildPartC()
        {
            product.setPartC("属性2C");
        }
    }

    //指挥者
    class Direcotr {
        //声明一个建造者对象
        private Builder builder;
        //指挥者的构造函数,因为指挥者类就是为了指挥建造者建造产品的，所以在构造函数里传入
        public Direcotr(Builder builder)    //这里传进来的是具体的建造者的对象
        {
            this.builder = builder;
        }
        //下面的方法为具体建造过程方法
        public Product Construct() {
            builder.BuildPartA();   //先建造1
            builder.BuildPartB();   //在建造2
            builder.BuildPartC();   //在建造3
            return builder.GetProduct();    //获得建造好得对象
        }
    }