大话设计模式--创建型

最新推荐文章于 2025-04-10 14:51:08 发布
最新推荐文章于 2025-04-10 14:51:08 发布
阅读量337 收藏
点赞数
分类专栏： 设计模式 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dfshsdr/article/details/78410169
版权

前言

我们学习的设计模式分为三类：创建者模式、结构型模式、行为型模式；当然它们都有自己的独到之处喽！创建型模式与对象的创建有关；结构型模式处理类或对象的组合；而行为型模式是对类或对象怎样交互和怎样分配职责进行描述；

这里写图片描述

内容

现在小编带你们先去了解创建型模式；

（一）工厂方法

  1. 定义

    定义了一个用于创建对象的接口，让子类决定实例化哪一个类；工厂方法使一个类的实例化延迟到其子类。

  2. 结构图：

这里写图片描述

  1. 实例：雷锋依然在人间
  2. 代码区
namespace 工厂方法_雷锋工厂
{
    class Program
    {
        static void Main(string[] args)
        {
            //基本方式:薛磊风代表大学生学习雷锋
            LeiFeng xueleifeng = new Undergraduate();

            xueleifeng.BuyRice();
            xueleifeng.Sweep();
            xueleifeng.Wash();

            LeiFeng student1 = new Undergraduate();
            student1.BuyRice();
            LeiFeng student2 = new Undergraduate();
            student2.Sweep();
            LeiFeng student3 = new Undergraduate();
            student3.Wash();          

            //工厂方法模式
            IFactory factory = new UndergraduateFactory();
            LeiFeng student = factory.CreateLeiFeng();
            student.BuyRice();
            student.Sweep();
            student.Wash();
            Console.Read();
        }
    }
    //雷锋
    class LeiFeng
    {
        public void Sweep()
        {
            Console.WriteLine("扫地");
        }

        public void Wash()
        {
            Console.WriteLine("洗衣");
        }

        public void BuyRice()
        {
            Console.WriteLine("买米");
        }
    }
    //学雷锋的大学生
    class Undergraduate : LeiFeng
    { }
    //社区志愿者
    class Volunteer : LeiFeng
    { }

    //雷锋工厂
    interface IFactory
    {
        LeiFeng CreateLeiFeng();
    }

    //学雷锋的大学生工厂
    class UndergraduateFactory : IFactory
    {
        public LeiFeng CreateLeiFeng()
        {
            return new Undergraduate();
        }
    }

    //社区志愿者工厂
    class VolunteerFactory : IFactory
    {
        public LeiFeng CreateLeiFeng()
        {
            return new Volunteer();
        }
    }

}

（二）抽象工厂

  1. 定义：

     提供了一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类

  2. 结构图：

    这里写图片描述

  3. 实例：“就不能不换DB吗？”

  4. 代码区

namespace 抽象工厂模式
{
    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();
            Console.Read();
        }
    }
    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    class ConcreteFactory1 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }
    abstract class AbstractProductA
    {
    }

    abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    class ProductA1 : AbstractProductA
    {
    }

    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    class ProductA2 : AbstractProductA
    {
    }

    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor 
        public Client(AbstractFactory factory)
        {
            AbstractProductB = factory.CreateProductB();
            AbstractProductA = factory.CreateProductA();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }


}

（三）建造者模式

  1. 定义：

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

  2. 结构图：

    这里写图片描述

  3. 实例：“好菜没回味不同”

  4. 代码区：

namespace 建造者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

            director.Construct(b1);
            Product p1 = b1.GetResult();
            p1.Show();

            director.Construct(b2);
            Product p2 = b2.GetResult();
            p2.Show();

            Console.Read();
        }
    }

    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }

    abstract class Builder
    {
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract Product GetResult();
    }

    class ConcreteBuilder1 : Builder
    {
        private Product product = new Product();

        public override void BuildPartA()
        {
            product.Add("部件A");
        }

        public override void BuildPartB()
        {
            product.Add("部件B");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    class ConcreteBuilder2 : Builder
    {
        private Product product = new Product();
        public override void BuildPartA()
        {
            product.Add("部件X");
        }

        public override void BuildPartB()
        {
            product.Add("部件Y");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    class Product
    {
        IList<string> parts = new List<string>();

        public void Add(string part)
        {
            parts.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("\n产品 创建 ----");
            foreach (string part in parts)
            {
                Console.WriteLine(part);
            }
        }
    }


}

（三）原型模式

  1. 定义：

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

  2. 结构图：
    这里写图片描述

  3. 实例： “复制简历”

  4. 代码区：

namespace 原型模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //克隆类 ConcretePrototype1的对象P1，就可以得到新的实例C1；
            ConcretePrototype1 p1 = new ConcretePrototype1("I");
            ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
            Console.WriteLine("Cloned: {0}", c1.Id);

            ConcretePrototype2 p2 = new ConcretePrototype2("II");
            ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone();
            Console.WriteLine("Cloned: {0}", c2.Id);

            // Wait for user 
            Console.Read();
        }
    }

    abstract class Prototype
    {
        private string id;

        // Constructor 
        public Prototype(string id)
        {
            this.id = id;
        }

        // Property 
        public string Id
        {
            get { return id; }
        }

        public abstract Prototype Clone();
    }

    class ConcretePrototype1 : Prototype
    {
        // Constructor 
        public ConcretePrototype1(string id)
            : base(id)
        {
        }

        public override Prototype Clone()
        {
            // Shallow copy 
            return (Prototype)this.MemberwiseClone();
        }
    }


    class ConcretePrototype2 : Prototype
    {
        // Constructor 
        public ConcretePrototype2(string id)
            : base(id)
        {
        }

        public override Prototype Clone()
        {
            // 抽象类的关键就是有这样一个Clone方法；
            return (Prototype)this.MemberwiseClone();
        }
    }
}

**（五）单例模式**

 1. 定义：

     保证一个类只有一个实例，并且提供一个访问它的全局访问点。

 2. 结构图：

     ![这里写图片描述](http://img.blog.youkuaiyun.com/20171101100720997?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGZzaHNkcg==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)

 3. 实例：“有些类也需要计划生育”

 4. 代码区：

namespace 单例模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();
            //比较两次实例化后对象的结果使实例相同；
            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }


    class Singleton
    {

        private static Singleton instance;
        private static readonly object syncRoot = new object();
        //构造方法让其Private，然后这就堵死了外界利用new创建此类实例的可能。
        private Singleton()
        {
        }
        //此方法就是获得本类实例的唯一全局访问点
        public static Singleton GetInstance()
        {
            //若实例不存在，则new一个新势力，否则返回已有的实例；
            if (instance == null)
            {

                lock (syncRoot)
                {

                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }

    }


}

总结

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

设计模式 - 创建型
唯细水静流
06-12 264
创建型设计模式简介。
大话设计模式-简单工厂模式
x1027105273的博客
04-09 1130
简单工厂模式阅读笔记
大话设计模式-设计模式篇
大话编程那些事儿的博客
05-18 257
设计模式简介 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦
大话设计模式-面向对象
One_Piece111的博客
03-11 958
大话设计模式-面向对象对象类实例化构造方法方法重载属性与修饰符属性的get和set封装继承protected多态重构抽象类接口 interface抽象类和接口的区别集合ArrayList拆箱和装箱泛型委托和事件 对象 对象是一个自包含的实体，用一组可识别的特性和行为来标识，英文名叫 Object-Oriented Programming 类 类就是具有相同的属性和功能的对象的抽象的集合，**class**是定义类的关键 两点注意：①类名称首字母记者要大写，多个单词则各个首字母大写； ②对外公开
【设计模式】创建型模式-概述
CCC的专栏
08-28 491
1 简介 创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。 根据范围可将创建型模式分为以下两种： 类创建型模式：使用***继承***改变被实例化的类; 对象创建型模式：将实例化委托给另一个对象。 随着系统演化得越来越依赖于对象复合而不是类继承，创建型模式变得更为重要。 2 五种创建型模式 名称 类型 抽象工厂模式（Abstract Fa...
【笔记】大话设计模式-11-13
RandyOliver's House
07-26 178
11 迪米特法则 12 外观模式 13 建造者模式(生成器模式）
设计模式 - 行为型
唯细水静流
06-12 916
行为型设计模式简介。
大话设计模式-原型模式(大鸟和小菜java版)
zhinaijiangya的博客
06-18 507
原型模式：原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。 本文的例子依旧是大鸟和小菜的例子，只是把书上的c++版本换成了Java版 创建一个工作类： package 设计模式.原型模式; //这个是工作类 public class Work implements Cloneable{ // 定义两个私有变量
大话设计模式 -- Golang实现
aa779025105的专栏
03-13 7761
DesignPatternUse GO language to achieve 23 design patterns 该项目是拜读《大话设计模式》后，学习Golang语言实现的，有很多不足之处，有待完善 有些模式是根据UML图编写的基本框架，有些是基于特定的环境下编写的实例创建型模式 Abstract Factory抽象工厂模式：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的
大话设计模式（更新ing...）
qq_45599754的博客
10-17 1832
Java设计模式
设计模式--大话设计
05-28
设计模式可以分为三类：创建型模式、结构型模式和行为型模式。下面我们逐一介绍这些模式及其在.NET开发中的应用： 1. **创建型模式**： - **工厂方法模式**：定义一个创建对象的接口，让子类决定实例化哪一个类。...
设计模式简述（九）命令模式
冰糖的博客
04-06 374
命令对象封装了该命令需要的所有逻辑，不需要调用方关注内部细节。命令模式是一种体现高内聚的行为模式。，由这个命令对象完成所需业务调用。将整个请求封装成一个。
【Java设计模式】第6章 抽象工厂模式讲解
cherry5230的博客
04-08 146
【代码】【Java设计模式】第6章 抽象工厂模式讲解。
Spring其它知识点
最新发布
m0_45253972的博客
04-10 334
Spring默认的Bean作用域是单例，多个线程同时操作同一个Bean实例。若Bean包含可变成员变量，可能引发线程安全问题。
设计模式 Day 3：抽象工厂模式（Abstract Factory Pattern）详解
Interview_TC的博客
04-06 804
抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。关键词：“一系列相关对象” → 产品族。
C++继承完全指南：从语法到设计模式----图解原理+工业级代码示例+陷阱规避
jsjs1346的博客
04-07 715
本文深入探讨了C++继承机制的核心原理与实战应用。首先通过Qt框架的成功案例与某电商系统的失败教训，对比分析了继承的优势与陷阱，指出合理使用继承需满足is-a关系且基类稳定。随后详细解析了单继承与多重继承的内存布局、虚函数机制的性能代价（约27%下降）以及对象切片等常见问题。文章重点介绍了现代C++替代方案，如组合模式、策略模式、类型擦除和CRTP，并通过性能数据对比展示了其优势。针对多重继承，揭示了编译器实现差异及虚继承的高成本（构造耗时增加150%），提出了接口隔离等解决方案。
【设计模式】创建型 -- 单例模式 （c++实现）
ProcedureStone的博客
04-08 956
在C++11 推出以前，局部静态变量的方式实现单例存在线程安全问题，所以部分人提出了一种方案，就是在主线程启动后，其他线程没有启动前，由主线程先初始化单例资源，这样其他线程获取的资源就不涉及重复初始化的情况了。当一个函数中定义一个局部静态变量，那么这个局部静态变量只会初始化一次，就是在这个函数第一次调用的时候，以后无论调用几次这个函数，函数内的局部静态变量都不再初始化。分配到内存后，new 操作会在刚刚分配的内存上调用对象的构造函数，初始化该对象的各个成员。即c++规定各厂商优化编译器，能保证线程安全。
设计模式（23种设计模式简介）
hycccccch的博客
04-09 707
设计模式是解决软件设计中常见问题的可重用解决方案模板，通过总结反复验证的代码设计经验，提升代码的可重用性、可维护性和扩展性。其核心是通过标准化的设计思想，让代码更易理解、协作更高效，并在面向对象编程中协调类与对象的交互关系。
大话设计模式 c++
09-13
设计模式是软件开发中常用的解决问题的方法论。它提供了一套经过实践验证的设计思想和模式，可以帮助开发人员更好地组织和管理代码，提高代码的可重用性、可扩展性和可维护性。 在大话设计模式中，作者通过讲述故事的形式，生动地介绍了23种设计模式，包括创建型模式、结构型模式和行为型模式。其中创建型模式包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式；结构型模式包括适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式和享元模式；行为型模式包括策略模式、观察者模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式和解释器模式。 每种设计模式都有其特定的应用场景和解决方案，可以根据实际需求选择合适的设计模式来解决问题。阅读《大话设计模式》可以帮助开发人员更好地理解和运用这些设计模式，提高代码的质量和可维护性。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值