大话设计模式--创建型

前言

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

内容

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

（一）工厂方法

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.csdn.net/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;        }    }}

总结

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