设计模式(创建型)

一：创建型设计模式整体总结图

 

 

二：具体设计模式

 

1，工厂方法模型

 

1）定义：

      定义一个用于创建对象的接口，让子类去决定实例化哪个类

2）优点：

      克服了简单工厂违背开放封闭原则的缺点，又保持了对象创建过程的优点

 

3）类图

 

 

2，抽象工厂

 

1）定义：

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

2）优点：

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

 

3）类图

 

 

3，单例模式

 

1）定义：

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

 

4，原型模式

 

1）定义：

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

 

2）类图

 

5，建造者模式

 

1）定义：

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

 

2）类图

三：代码实现

 

   快要过年啦，很多同学都在网上购买火车票回家，有时候还是买不上票。现在就以火车票为例，运用设计模式的思想，去练习巩固设计模式。

 

1，简单工厂

 假如，规定好乘车区间，学生票票价是100，成人票价为200，要求简单显示购买火车票类型极其票价

 

类图：

 

代码实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 火车票
{
    class Program
    {
        static void Main(string[] args)
        {
            Ticket ticket = FactoryTicket.CreateTicket("学生票");  //传入参数“学生票”，让火车票工厂去实例化对象的学生票类
            ticket.GetTicket();
 
            Ticket ticket2 = FactoryTicket.CreateTicket("成人票");
            ticket2.GetTicket();
 
            Console.Read();
        }
    }


    //火车票工厂
    class FactoryTicket
    {
        public static Ticket CreateTicket(string type)//根据提供的类型，去实例化具体的火车票对象
        {
            Ticket ticket = null;
            switch (type)
            { 
                case"学生票":
                    ticket = new StudentTicket();  //如果是学生票，则返回学生票子类
                    break;
                case"成人票":
                    ticket = new GeneralTicket();  //如果是成人票，则返回成人票子类
                    break;
            }
            return ticket;
        }
    }

    //火车票基类
    class Ticket
    {
        private string money;
        public string Money
        {
            get { return money; }
            set { money = value; }
        }
        public virtual void GetTicket() //打印获得火车票的类型和价钱
        { }
    }

    //学生票
    class StudentTicket:Ticket
    {
        private string money = "100";
        
        public override void GetTicket()
        { 
            Console .WriteLine ("您选择的是 学生票，票价为：{0}元",money );
        }
    }
    //成人票
    class GeneralTicket:Ticket 
    {
        private string money = "200";
        public override void  GetTicket()
        {
            Console.WriteLine("您选择的是 成人票，票价为：{0}元",money );
        }
    }
}

 

运行结果：

 

 

2，抽象工厂

假设购买火车票的人只有姓名一个属性，要求，显示购买火车票或成人票。

类图

类图：

代码实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 火车票
{
    class Program
    {
        static void Main(string[] args)
        {
            People li = new People("李");//实例化购买火车票的人li
            IFactoryTicket factory = new StuTicketFactory();
            ITicket iticket = factory.CreateTicket();
            iticket.GetTicket();

            Console.Read();


        }
    }


    //火车票工厂接口，定义一个创建火车票的抽象工厂接口
    interface IFactoryTicket
    {
        ITicket CreateTicket();
    }


    //实现IFactoryTicket接口，实例化StudentTicket
    class StuTicketFactory:IFactoryTicket 
    {
        public ITicket CreateTicket()
        {
            return new StudentTicket();
        }
    }
    //实现IFactoryTicket接口，实例化GeneralTicket
    class GenTicketFactory : IFactoryTicket
    {
        public ITicket CreateTicket()
        {
            return new GeneralTicket();
        }
    }



    //火车票基类
    interface  ITicket
    {
        void GetTicket(); //打印获得火车票的类型和价钱
       
    }

    //学生票
    class StudentTicket:ITicket
    {     
        public  void GetTicket()
        { 
            Console .WriteLine ("您选择的是 学生票 ");
        }
    }
    //成人票
    class GeneralTicket:ITicket 
    {
        
        public  void  GetTicket()
        {
            Console.WriteLine("您选择的是 成人票 ");
        }
    }

    //定义购买火车票的人类
    class People
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public People() { }
        public People(string name)
        {
            this.name = name;
        }
    }
}

运行结果：

 

 

3，原型模式

假设，车票只显示购票者的姓名，票的类型（学生票，成人票），分别打印学生票和成人票，这里仅一张学生票，一张成人票（打印的票数多了，原型模式就方便啦）。

采用原型模式，通过拷贝原型创建不同的火车票。

类图：

代码实现：

namespace 火车票
{
    class Program
    {
        static void Main(string[] args)
        {
            Ticket ticket1 = new Ticket("li");
            ticket1.Type("学生票");
            ticket1.GetTicket();


            Ticket ticket2 = new Ticket("lisz");
            ticket2.Type("成人票");
            ticket2.GetTicket();


            Console.Read();
                     
        }
    }


    class Ticket : ICloneable
    {
        private string username;
        private string type;

        public Ticket(string username)
        {
            this.username = username;
        }
        public void Type(string type)
        {
            this.type = type;
        }
        public void GetTicket()
        {
            Console.WriteLine("{0}:您购买的是{1}", username, type);
        }

        public object Clone()
        {
            return (object)this.MemberwiseClone();
        }
    }

}

运行结果：

 

 

4，单例模式

一个用户只能购买一张车次的票，假如时间段确定，车次确定。

双重锁定，代码实现：

namespace 火车票
{
    class Program
    {
        static void Main(string[] args)
        {
            Ticket ticket = Ticket.GetTicket();
            Ticket ticket1 = Ticket.GetTicket();

            if (ticket == ticket1)
            {
                Console.WriteLine("两个对象是相同的实例");
            }
            Console.Read();
        }    
       
    }


    class Ticket
    {
        private static Ticket instance;
        private static readonly object syncRoot = new object();//程序运行时，创建一个静态只读的进程辅助对象

        private string username;
        public Ticket() { }


        public static Ticket GetTicket()
        {
            if (instance == null)//先判断实例是否存在，不存在再进行加锁处理
            {
                lock (syncRoot)
                {
                    if (instance == null)
                    {
                        instance = new Ticket();
                    }
                }
            }
            return instance;
        }
    }


}

四：总结适用性

 

1，工厂方法模型

    工厂模式用来生产同一等级结构中的固定产品

    当类不知道他所创建的对象的类

 

2，抽象工厂模型

     抽象工厂模式用来生产不同产品族的全部产品

    当要强调一系列相关的产品对象设计，以便进行联合使用

    当提供一个产品类库，而只是想显示他们的接口而不是实现时

 

3，单例模式

     当类只能由一个实例，而且客户可以从一个众所周知的访问点访问他

     当唯一的实例是通过子类实例化的，而且无需更改代码就能实现扩展

 

4，原型模式

     当要实例化的类是在运行时指定

     当一个类的实例只能由几个不同状态组合中的一种

 

5，建造者模式

     当创建复杂对象的算法独立于该对象的组成部分