面向对象23种设计模式系列（一）- 创建型设计模式
本章是面向对象23种设计模式系列开篇，首先我们来看下什么是设计模式？
面向对象23种设计模式：
1、面向对象语言开发过程中，遇到的种种场景和问题，提出了解决方案和思路，沉淀下来就变成了设计模式。
2、解决具体问题的具体招数---套路---站在前辈的肩膀上。
3、没有什么设计模式是完美无缺的，一种设计模式就是解决一类问题，通常设计模式在解决一类问题的同时，还会带来别的问题，我们设计者要做的事儿，就是要扬长避短，充分发挥长处！
设计模式可以大概分为三大类：
1、创建型设计模式：关注对象的创建。
2、结构型设计模式：关注类与类之间的关系。
3、行为型设计模式：关注对象和行为的分离。
我们要做的就是学习核心套路，这里就不做过多的描述，如果有机会会通过具体例子再和大家分享。下面我们正式进入本章主题。
创建型设计模式：关注对象的创建。（5个）
1、单例模式（Singleton Pattern）
单例模式：
就是限制了对象的创建，重用了对象。保证进程中，某个类只有一个实例。
即使是单例，变量也不是线程安全的，单例不是为了保证线程安全。
单例的好处就是单例，就是全局唯一的一个实例。
应对一些特殊情况，比如数据库连接池(内置了资源) ，全局唯一号码生成器。
单例可以避免重复创建，但是也会常驻内存，除非是真的有必要，否则就不要使用单例。
1.1、单例模式经典写法（懒汉式）
using System; using System.Threading; namespace SingletonPattern { /// <summary> /// 懒汉式单例模式（经典写法） /// 单例类：一个构造对象很耗时耗资源类型。 /// </summary> public class Singleton { /// <summary> /// 构造函数耗时耗资源 /// </summary> private Singleton() { long lResult = 0; for (int i = 0; i < 10000000; i++) { lResult += i; } Thread.Sleep(2000); Console.WriteLine("{0}被构造一次", this.GetType().Name); } /// <summary> /// 全局唯一静态 重用这个变量 /// volatile 促进线程安全 让线程按顺序操作 /// </summary> private static volatile Singleton _singleton = null; /// <summary> /// 引用类型对象 /// </summary> private static readonly object lockSingleton = new object(); /// <summary> /// 公开的静态方法提供对象实例 /// </summary> /// <returns> /// </returns> public static Singleton CreateInstance() { if (_singleton == null) //_singleton已经被初始化之后，就不要进入锁等待了 { //保证任意时刻只有一个线程进入lock范围 //也限制了并发，尤其是_singleton已经被初始化之后，故使用了双if来解决并发限制问题 lock (lockSingleton) { //Thread.Sleep(1000); //Console.WriteLine("等待锁1s之后才继续。。。"); if (_singleton == null) //保证只实例化一次 { _singleton = new Singleton(); } } } return _singleton; } public int iTotal = 0; /// <summary> /// 既然是单例，大家用的是同一个对象，用的是同一个方法，那还会并发吗 还有线程安全问题吗？ /// 即使是单例，变量也不是线程安全的，单例不是为了保证线程安全。 /// </summary> public void Increment() { //lock (lockSingleton) //{ this.iTotal++; //} } public static void Show() { Console.WriteLine(_singleton.iTotal); } } }
使用如下：
using System; using System.Collections.Generic; using System.Threading.Tasks; namespace SingletonPattern { /// <summary> /// 为什么要有单例设计模式？ /// 构造对象耗时耗资源，很多地方都需要去new， 这个方法 其他方法 其他类 /// </summary> class Program { static void Main(string[] args) { try { { //保证进程中，某个类只有一个实例 //1 构造函数私有化 避免别人还去new //2 公开的静态方法提供对象实例 //3 初始化一个静态字段用于返回 保证全局都是这一个 Singleton singleton1 = Singleton.CreateInstance(); Singleton singleton2 = Singleton.CreateInstance(); Singleton singleton3 = Singleton.CreateInstance(); Console.WriteLine(object.ReferenceEquals(singleton1, singleton2)); Console.WriteLine(object.ReferenceEquals(singleton3, singleton2)); } { List<Task> tasks = new List<Task>(); for (int i = 0; i < 10000; i++) { tasks.Add(Task.Run(() => { Singleton singleton = Singleton.CreateInstance(); singleton.Increment(); })); } Task.WaitAll(tasks.ToArray()); Singleton.Show(); //即使是单例，变量也不是线程安全的，单例不是为了保证线程安全。 //iTotal 是0 1 10000 还是其他的 //结果为：其他值，1到10000范围内都可能 线程不安全 } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read(); } } }
1.2、饿汉式写法（静态构造函数）
using System; using System.Threading; namespace SingletonPattern { /// <summary> /// 饿汉式 /// </summary> public class SingletonSecond { private static SingletonSecond _singletonSecond = null; /// <summary> /// 构造函数耗时耗资源 /// </summary> private SingletonSecond() { long lResult = 0; for (int i = 0; i < 10000000; i++) { lResult += i; } Thread.Sleep(1000); Console.WriteLine("{0}被构造一次", this.GetType().Name); } /// <summary> /// 静态构造函数：由CLR保证，程序第一次使用这个类型前被调用，且只调用一次。 /// </summary> static SingletonSecond() { _singletonSecond = new SingletonSecond(); Console.WriteLine("SingletonSecond 被启动"); } /// <summary> /// 饿汉式 只要使用类就会被构造 /// </summary> /// <returns> /// </returns> public static SingletonSecond CreateInstance() { return _singletonSecond; } } }
1.3、饿汉式写法（静态字段）
using System; using System.Threading; namespace SingletonPattern { /// <summary> /// 饿汉式 /// </summary> public class SingletonThird { /// <summary> /// 静态字段：在第一次使用这个类之前，由CLR保证，初始化且只初始化一次。 /// 这个比构造函数还早 /// </summary> private static SingletonThird _singletonThird = new SingletonThird(); //打印个日志 /// <summary> /// 构造函数耗时耗资源 /// </summary> private SingletonThird() { long lResult = 0; for (int i = 0; i < 10000000; i++) { lResult += i; } Thread.Sleep(1000); Console.WriteLine("{0}被构造一次", this.GetType().Name); } /// <summary> /// 饿汉式 只要使用类就会被构造 /// </summary> /// <returns> /// </returns> public static SingletonThird CreateInstance() { return _singletonThird; } public void Show() { Console.WriteLine("这里是{0}.Show", this.GetType().Name); } } }
2、原型模式（Prototype Pattern）
原型模式：
换个方式创建对象，不走构造函数，而是内存拷贝。
单例的基础上升级了一下，把对象从内存层面复制了一下，然后返回。
是个新对象，但是又不是new出来的。
using System; using System.Threading; namespace PrototypePattern { /// <summary> /// 原型模式：单例的基础上升级了一下，把对象从内存层面复制了一下，然后返回。 /// 是个新对象，但是又不是new出来的。 /// </summary> public class Prototype { /// <summary> /// 构造函数耗时耗资源 /// </summary> private Prototype() { long lResult = 0; for (int i = 0; i < 10000000; i++) { lResult += i; } Thread.Sleep(2000); Console.WriteLine("{0}被构造一次", this.GetType().Name); } /// <summary> /// 全局唯一静态 重用这个变量 /// </summary> private static volatile Prototype _prototype = new Prototype(); /// <summary> /// 公开的静态方法提供对象实例 /// </summary> /// <returns> /// </returns> public static Prototype CreateInstance() { Prototype prototype = (Prototype)_prototype.MemberwiseClone(); //从内存层面复制 return prototype; } } }
下面为了演示鼎鼎大名的三大工厂我们创建几个接口和类：
/// <summary> /// 种族 /// </summary> public interface IRace { void ShowKing(); } /// <summary> /// 军队 /// </summary> public interface IArmy { void ShowArmy(); } /// <summary> /// 英雄 /// </summary> public interface IHero { void ShowHero(); } /// <summary> /// 资源 /// </summary> public interface IResource { void ShowResource(); } /// <summary> /// 幸运值 /// </summary> public interface ILuck { void ShowLuck(); }
using System; using FactoryPattern.War3.Interface; namespace FactoryPattern.War3.Service { /// <summary> /// 人族（War3种族之一） /// </summary> public class Human : IRace { public Human(int id, DateTime dateTime, string reamrk) { } public Human() { } public void ShowKing() { Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Sky"); } } public class HumanArmy : IArmy { public void ShowArmy() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "footman，火枪，骑士，狮鹫"); } } public class HumanHero : IHero { public void ShowHero() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "大法师、山丘、圣骑士、血法师"); } } public class HumanResource : IResource { public void ShowResource() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "1000G1000W"); } } }
using System; using FactoryPattern.War3.Interface; namespace FactoryPattern.War3.Service { /// <summary> /// 不死族（War3种族之一） /// </summary> public class Undead : IRace { public void ShowKing() { Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "GoStop"); } } public class UndeadArmy : IArmy { public void ShowArmy() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "食尸鬼,蜘蛛，雕像，战车，憎恶，冰霜巨龙"); } } public class UndeadHero : IHero { public void ShowHero() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "DK、Lich、小强、恐惧魔王"); } } public class UndeadResource : IResource { public void ShowResource() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "1000G1000W"); } } }
using System; using FactoryPattern.War3.Interface; namespace FactoryPattern.War3.Service { /// <summary> /// War3种族之一 /// </summary> public class ORC : IRace { public void ShowKing() { Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Grubby"); } } public class ORCArmy : IArmy { public void ShowArmy() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "大G、风骑士、蝙蝠、战车、牛头人"); } } public class ORCHero : IHero { public void ShowHero() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "剑圣、小萨满、先知、牛头人酋长"); } } public class ORCResource : IResource { public void ShowResource() { Console.WriteLine("The Army of {0} is {1}", this.GetType().Name, "1000G1000W"); } } }
using System; using FactoryPattern.War3.Interface; namespace FactoryPattern.War3.Service { /// <summary> /// War3种族之一 /// </summary> public class NE : IRace { public void ShowKing() { Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Moon"); } } }
3、简单工厂（Simple Factory）
简单工厂：不直接new，把对象创建转移到工厂类。（简单工厂不属于23种设计模式）
核心代码如下：
using System; using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace SimpleFactory { /// <summary> /// 简单工厂 /// </summary> public class ObjectFactory { /// <summary> /// 细节没有消失 只是转移 /// 转移了矛盾，并没有消除矛盾 /// 此处集中了矛盾 /// </summary> /// <param name="raceType"> /// </param> /// <returns> /// </returns> public static IRace CreateRace(RaceType raceType) { IRace iRace; switch (raceType) { case RaceType.Human: iRace = new Human(); break; case RaceType.Undead: iRace = new Undead(); break; case RaceType.ORC: iRace = new ORC(); break; case RaceType.NE: iRace = new NE(); break; //每增加一个分支就需要修改代码 default: throw new Exception("wrong raceType"); } return iRace; } } /// <summary> /// 种族类型枚举 /// </summary> public enum RaceType { Human, Undead, ORC, NE } }
using System; using FactoryPattern.War3.Interface; namespace SimpleFactory { /// <summary> /// 玩家 /// </summary> public class Player { public int Id { get; set; } public string Name { get; set; } /// <summary> /// 面向抽象 /// </summary> /// <param name="race"> /// 种族 /// </param> public void PlayWar3(IRace race) { Console.WriteLine("******************************"); Console.WriteLine("This is {0} Play War3.{1}", this.Name, race.GetType().Name); race.ShowKing(); } } }
using System; using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace SimpleFactory { /// <summary> /// 简单工厂：非常简单的工厂 /// 工厂就是创建对象的地方 /// </summary> class Program { static void Main(string[] args) { try { Player player = new Player() { Id = 123, Name = "候鸟" }; { Human human = new Human();//1 到处都是细节 player.PlayWar3(human); } { IRace human = new Human();//2 左边是抽象 右边是细节 player.PlayWar3(human); } { IRace human = ObjectFactory.CreateRace(RaceType.Human); //3 没有细节 细节被转移 player.PlayWar3(human); } { IRace undead = ObjectFactory.CreateRace(RaceType.Undead); //4 没有细节 细节被转移 player.PlayWar3(undead); } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read(); } } }
4、工厂方法模式（Factory Method Pattern）
工厂方法模式：
屏蔽对象的创建，留下了扩展空间。
把简单工厂拆分成多个工厂，保证每个工厂的相对稳定。
多new一次工厂，难免，中间层，屏蔽业务类变化的影响，而且可以留下创建对象的扩展空间。
核心代码如下：
using FactoryPattern.War3.Interface; namespace FactoryMethod.Factory { public interface IFactory { /// <summary> /// 创建种族 /// </summary> /// <returns> /// </returns> IRace CreateRace(); } }
using System; using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace FactoryMethod.Factory { public class HumanFactory : IFactory { public virtual IRace CreateRace() { return new Human(); } } /// <summary> /// 后期可以对其扩展 /// </summary> public class HumanFactoryAdvanced : HumanFactory { public override IRace CreateRace() { Console.WriteLine("123"); return new Human(); } } }
using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace FactoryMethod.Factory { public class UndeadFactory : IFactory { public IRace CreateRace() { return new Undead(); } } }
using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace FactoryMethod.Factory { public class ORCFactory : IFactory { public IRace CreateRace() { return new ORC(); } } }
using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace FactoryMethod.Factory { public class NEFactory : IFactory { public IRace CreateRace() { return new NE(); } } }
using System; using FactoryMethod.Factory; using FactoryPattern.War3.Interface; namespace FactoryMethod { /// <summary> /// 工厂方法：把简单工厂拆分成多个工厂，保证每个工厂的相对稳定。 /// 但是要多new一次工厂？ 难免，中间层，屏蔽业务类变化的影响，而且可以留下创建对象的扩展空间。 /// 开闭原则：对扩展开发，对修改封闭。 /// 工厂方法完美遵循了开闭原则 /// </summary> class Program { static void Main(string[] args) { try { { //human IFactory factory = new HumanFactory();//包一层 IRace race = factory.CreateRace(); //何苦 搞了这么多工厂 还不是创建个对象 //以前依赖的是Human 现在换成了HumanFactory //1 工厂可以增加一些创建逻辑 屏蔽对象实例化的复杂度 //2 对象创建的过程中 可能扩展(尤其是ioc) } { //Undead IFactory factory = new UndeadFactory(); IRace race = factory.CreateRace(); } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read(); } } }
可以看出工厂方法模式，就是把简单工厂拆分成多个工厂，保证每个工厂的相对稳定。多new一次工厂，难免，中间层，屏蔽业务类变化的影响，而且可以留下创建对象的扩展空间。
另外工厂方法完美遵循了开闭原则，例如：Demo中原先我们有4个种族，分别为Human、Undead、ORC和NE，此时如果业务发生变化需要增加一个Five种族，
这时候我们只需要添加一个Five工厂类就好了，不会影响原来的代码。
using System; using FactoryPattern.War3.Interface; namespace FactoryPattern.War3.ServiceExtend { /// <summary> /// War3种族之一 /// </summary> public class Five : IRace { public Five() : this(1, "old", 1) //当前类的构造函数 { } public Five(int id, string name, int version) { } public void ShowKing() { Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Moon"); } } }
using FactoryPattern.War3.Interface; using FactoryPattern.War3.ServiceExtend; namespace FactoryMethod.Factory { /// <summary> /// 比如构造很复杂。。比如依赖其他对象 /// 屏蔽变化 /// </summary> public class FiveFactory : IFactory { public virtual IRace CreateRace() { //return new Five(); return new Five(2, "New", 2); } } }
5、抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式：
屏蔽对象的创建，约束强制保障产品簇。
创建一组密不可分的对象。
创建产品簇：创建一组密不可分的对象。
工厂+约束
倾斜的可扩展性设计，扩展种族很方便，增加产品很麻烦。
核心代码如下：
using FactoryPattern.War3.Interface; namespace AbstractFactory.Factory { /// <summary> /// 一个工厂负责一些产品的创建 /// 产品簇 /// 单一职责就是创建完整的产品簇 /// /// 继承抽象类后，必须显式的override父类的抽象方法。 /// </summary> public abstract class FactoryAbstract { public abstract IRace CreateRace(); public abstract IArmy CreateArmy(); public abstract IHero CreateHero(); public abstract IResource CreateResource(); //倾斜的可扩展性设计：扩展种族很方便，增加产品(元素)很麻烦。 //public abstract ILuck CreateLuck(); //增加产品(元素)则每个种族的代码都要修改 } }
using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace AbstractFactory.Factory { /// <summary> /// 一个工厂负责一些产品的创建 /// </summary> public class HumanFactory : FactoryAbstract { public override IRace CreateRace() { return new Human(); } public override IArmy CreateArmy() { return new HumanArmy(); } public override IHero CreateHero() { return new HumanHero(); } public override IResource CreateResource() { return new HumanResource(); } } }
using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace AbstractFactory.Factory { /// <summary> /// 一个工厂负责一些产品的创建 /// </summary> public class UndeadFactory : FactoryAbstract { public override IRace CreateRace() { return new Undead(); } public override IArmy CreateArmy() { return new UndeadArmy(); } public override IHero CreateHero() { return new UndeadHero(); } public override IResource CreateResource() { return new UndeadResource(); } } }
using System; using AbstractFactory.Factory; using FactoryPattern.War3.Interface; using FactoryPattern.War3.Service; namespace AbstractFactory { /// <summary> /// 抽象工厂：创建一组密不可分的对象。 /// 创建产品簇：多个对象是个整体，不可分割。 /// /// 工厂+约束 /// /// 倾斜的可扩展性设计：扩展种族很方便，增加产品(元素)很麻烦。 /// </summary> class Program { static void Main(string[] args) { try { Console.WriteLine("想要玩一款游戏，必须4大元素备齐"); //System.Data.SqlClient.SqlClientFactory //使用的就是抽象工厂模式 { IRace race = new Undead(); IArmy army = new UndeadArmy(); IHero hero = new UndeadHero(); IResource resource = new UndeadResource(); //1 对象转移，屏蔽细节，让使用者更轻松 //2 对象簇的工厂 } { FactoryAbstract undeadFactory = new UndeadFactory(); IRace race = undeadFactory.CreateRace();// new Undead(); IArmy army = undeadFactory.CreateArmy();//new UndeadArmy(); IHero hero = undeadFactory.CreateHero();//new UndeadHero(); IResource resource = undeadFactory.CreateResource();//new UndeadResource(); } { FactoryAbstract humanFactory = new HumanFactory(); IRace race = humanFactory.CreateRace(); IArmy army = humanFactory.CreateArmy(); IHero hero = humanFactory.CreateHero(); IResource resource = humanFactory.CreateResource(); } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read(); } } }
可以看出抽象工厂模式，屏蔽对象的创建，约束强制保障产品簇，创建一组密不可分的对象（例如：Demo中每个种族都有四个密不可分的元素，分别为Race、Army、Hero和Resource）。
另外抽象工厂模式是倾斜的可扩展性设计，扩展种族很方便，增加产品(元素)很麻烦，例如在Demo中如果产品簇增加一个Luck元素则每个种族的代码都需要修改。
6、建造者模式（Builder Pattern）
建造者模式：复杂的工厂方法。
Demo源码：
链接：https://pan.baidu.com/s/1x_quZxEUpCmqqc3Gf-QlFg 提取码：h1py
此文由博主精心撰写转载请保留此原文链接：https://www.cnblogs.com/xyh9039/p/13258500.html
版权声明：如有雷同纯属巧合，如有侵权请及时联系本人修改，谢谢！！！
