设计模式(创建型)

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

 

 

二：具体设计模式

 

1，工厂方法模型

 

1）定义：

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

2）优点：

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

 

3）类图

 

 

2，抽象工厂

 

1）定义：

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

2）优点：

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

 

3）类图

 

 

3，单例模式

 

1）定义：

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

 

4，原型模式

 

1）定义：

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

 

2）类图

 

5，建造者模式

 

1）定义：

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

 

2）类图

三：代码实现

 

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

 

1，简单工厂

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

 

类图：

 

代码实现：

[csharp] view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace 火车票  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             Ticket ticket = FactoryTicket.CreateTicket("学生票");  //传入参数“学生票”，让火车票工厂去实例化对象的学生票类  
13.             ticket.GetTicket();  
14.    
15.             Ticket ticket2 = FactoryTicket.CreateTicket("成人票");  
16.             ticket2.GetTicket();  
17.    
18.             Console.Read();  
19.         }  
20.     }  
21.   
22.   
23.     //火车票工厂   
24.     class FactoryTicket  
25.     {  
26.         public static Ticket CreateTicket(string type)//根据提供的类型，去实例化具体的火车票对象  
27.         {  
28.             Ticket ticket = null;  
29.             switch (type)  
30.             {   
31.                 case"学生票":  
32.                     ticket = new StudentTicket();  //如果是学生票，则返回学生票子类  
33.                     break;  
34.                 case"成人票":  
35.                     ticket = new GeneralTicket();  //如果是成人票，则返回成人票子类  
36.                     break;  
37.             }  
38.             return ticket;  
39.         }  
40.     }  
41.   
42.     //火车票基类   
43.     class Ticket  
44.     {  
45.         private string money;  
46.         public string Money  
47.         {  
48.             get { return money; }  
49.             set { money = value; }  
50.         }  
51.         public virtual void GetTicket() //打印获得火车票的类型和价钱  
52.         { }  
53.     }  
54.   
55.     //学生票   
56.     class StudentTicket:Ticket  
57.     {  
58.         private string money = "100";  
59.           
60.         public override void GetTicket()  
61.         {   
62.             Console .WriteLine ("您选择的是 学生票，票价为：{0}元",money );  
63.         }  
64.     }  
65.     //成人票   
66.     class GeneralTicket:Ticket   
67.     {  
68.         private string money = "200";  
69.         public override void  GetTicket()  
70.         {  
71.             Console.WriteLine("您选择的是 成人票，票价为：{0}元",money );  
72.         }  
73.     }  
74. }  

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，抽象工厂

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

类图

类图：

代码实现：

[csharp] view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace 火车票  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             People li = new People("李");//实例化购买火车票的人li  
13.             IFactoryTicket factory = new StuTicketFactory();  
14.             ITicket iticket = factory.CreateTicket();  
15.             iticket.GetTicket();  
16.   
17.             Console.Read();  
18.   
19.   
20.         }  
21.     }  
22.   
23.   
24.     //火车票工厂接口，定义一个创建火车票的抽象工厂接口   
25.     interface IFactoryTicket  
26.     {  
27.         ITicket CreateTicket();  
28.     }  
29.   
30.   
31.     //实现IFactoryTicket接口，实例化StudentTicket  
32.     class StuTicketFactory:IFactoryTicket   
33.     {  
34.         public ITicket CreateTicket()  
35.         {  
36.             return new StudentTicket();  
37.         }  
38.     }  
39.     //实现IFactoryTicket接口，实例化GeneralTicket  
40.     class GenTicketFactory : IFactoryTicket  
41.     {  
42.         public ITicket CreateTicket()  
43.         {  
44.             return new GeneralTicket();  
45.         }  
46.     }  
47.   
48.   
49.   
50.     //火车票基类   
51.     interface  ITicket  
52.     {  
53.         void GetTicket(); //打印获得火车票的类型和价钱  
54.          
55.     }  
56.   
57.     //学生票   
58.     class StudentTicket:ITicket  
59.     {       
60.         public  void GetTicket()  
61.         {   
62.             Console .WriteLine ("您选择的是 学生票 ");  
63.         }  
64.     }  
65.     //成人票   
66.     class GeneralTicket:ITicket   
67.     {  
68.           
69.         public  void  GetTicket()  
70.         {  
71.             Console.WriteLine("您选择的是 成人票 ");  
72.         }  
73.     }  
74.   
75.     //定义购买火车票的人类   
76.     class People  
77.     {  
78.         private string name;  
79.         public string Name  
80.         {  
81.             get { return name; }  
82.             set { name = value; }  
83.         }  
84.         public People() { }  
85.         public People(string name)  
86.         {  
87.             this.name = name;  
88.         }  
89.     }  
90. }  

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，原型模式

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

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

类图：

代码实现：

[csharp] view plain copy print ?

1. namespace 火车票  
2. {  
3.     class Program  
4.     {  
5.         static void Main(string[] args)  
6.         {  
7.             Ticket ticket1 = new Ticket("li");  
8.             ticket1.Type("学生票");  
9.             ticket1.GetTicket();  
10.   
11.   
12.             Ticket ticket2 = new Ticket("lisz");  
13.             ticket2.Type("成人票");  
14.             ticket2.GetTicket();  
15.   
16.   
17.             Console.Read();  
18.                        
19.         }  
20.     }  
21.   
22.   
23.     class Ticket : ICloneable  
24.     {  
25.         private string username;  
26.         private string type;  
27.   
28.         public Ticket(string username)  
29.         {  
30.             this.username = username;  
31.         }  
32.         public void Type(string type)  
33.         {  
34.             this.type = type;  
35.         }  
36.         public void GetTicket()  
37.         {  
38.             Console.WriteLine("{0}:您购买的是{1}", username, type);  
39.         }  
40.   
41.         public object Clone()  
42.         {  
43.             return (object)this.MemberwiseClone();  
44.         }  
45.     }  
46.   
47. }  

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，单例模式

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

双重锁定，代码实现：

[csharp] view plain copy print ?

1. namespace 火车票  
2. {  
3.     class Program  
4.     {  
5.         static void Main(string[] args)  
6.         {  
7.             Ticket ticket = Ticket.GetTicket();  
8.             Ticket ticket1 = Ticket.GetTicket();  
9.   
10.             if (ticket == ticket1)  
11.             {  
12.                 Console.WriteLine("两个对象是相同的实例");  
13.             }  
14.             Console.Read();  
15.         }      
16.          
17.     }  
18.   
19.   
20.     class Ticket  
21.     {  
22.         private static Ticket instance;  
23.         private static readonly object syncRoot = new object();//程序运行时，创建一个静态只读的进程辅助对象  
24.   
25.         private string username;  
26.         public Ticket() { }  
27.   
28.   
29.         public static Ticket GetTicket()  
30.         {  
31.             if (instance == null)//先判断实例是否存在，不存在再进行加锁处理  
32.             {  
33.                 lock (syncRoot)  
34.                 {  
35.                     if (instance == null)  
36.                     {  
37.                         instance = new Ticket();  
38.                     }  
39.                 }  
40.             }  
41.             return instance;  
42.         }  
43.     }  
44.   
45.   
46. }  

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，建造者模式

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

更多设计模式：http://blog.csdn.net/column/details/designpattern.html