设计模式速查版 - 创建型
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
1）工厂方法模式（Factory Method Pattern）
2）抽象工厂模式（Abstract Factory Pattern）
3）建造者模式（Builder Pattern）
4）原型模式（Prototype Pattern）
5）单例模式（Singleton Pattern）
1.工厂方法
1)结构图:
2)代码:
View Code
1 /// 抽象工厂
2 public interface IFactory
3 {
4 /// <summary></summary>
5 Product FactoryMethod();
6 }
7
8 /// 抽象产品类
9 public abstract class Product
10 {
11 public virtual void show()
12 {
13 Console.Write("I'm product");
14 }
15 }
16
17 /// 工厂A
18 public class FactoryA : IFactory
19 {
20 /// <summary></summary>
21 public Product FactoryMethod()
22 {
23 return new ProductA();
24 }
25 }
26
27 /// 工厂B
28 public class FactoryB : IFactory
29 {
30 /// <summary></summary>
31 public Product FactoryMethod()
32 {
33 return new ProductB();
34 }
35 }
36
37 /// 产品A
38 public class ProductA : Product
39 {
40 public override void show()
41 {
42 Console.Write("I'm productA");
43 }
44 }
45
46 /// 产品B
47 public class ProductB : Product
48 {
49 public override void show()
50 {
51 Console.Write("I'm productB");
52 }
53 }
54
55 class Program
56 {
57 static void Main(string[] args)
58 {
59 IFactory factory = new FactoryA(); //控制具体要哪个产品
60 Product product = factory.FactoryMethod();
61 product.show();
62 Console.ReadLine();
63 }
64 }
3)
优点: 工厂方法使得一个类的实例化延迟到其子类.
适用: 客户端的加工逻辑只需要知道是哪类产品,而不需知道具体的产品名.这样不同的产品就可以复用相同的加工逻辑.
2.抽象工厂
1)结构图:
2)代码:
View Code
1 /// <summary>
2 /// 抽象工厂
3 /// </summary>
4 public interface IAbstractFactory
5 {
6 /// <summary></summary>
7 AbstractProductA CreateProductA();
8 /// <summary></summary>
9 AbstractProductB CreateProductB();
10 }
11
12 /// 工厂1
13 public class Factory1 : IAbstractFactory
14 {
15 /// 生产系列1的A产品
16 public AbstractProductA CreateProductA()
17 {
18 return new ProductA1();
19 }
20 /// 生产系列1的B产品
21 public AbstractProductB CreateProductB()
22 {
23 return new ProductB1();
24 }
25 }
26
27 /// 工厂2
28 public class Factory2 : IAbstractFactory
29 {
30 /// 生产系列2的A产品
31 public AbstractProductA CreateProductA()
32 {
33 return new ProductA2();
34 }
35 /// 生产系列2的B产品
36 public AbstractProductB CreateProductB()
37 {
38 return new ProductB2();
39 }
40 }
41
42 /// 抽象A产品
43 public abstract class AbstractProductA
44 {
45 }
46
47 /// 系列1的A产品
48 public class ProductA1 : AbstractProductA
49 {
50 }
51
52 /// 系列2的A产品
53 public class ProductA2 : AbstractProductA
54 {
55 }
56
57 /// 抽象B产品
58 public abstract class AbstractProductB
59 {
60 }
61
62 /// 系列1的B产品
63 public class ProductB1 : AbstractProductB
64 {
65 }
66
67 /// 系列2的B产品
68 public class ProductB2 : AbstractProductB
69 {
70 }
71
72 class Program
73 {
74 static void Main(string[] args)
75 {
76 IAbstractFactory factory = new Factory1(); //控制生成哪个系列的产品
77 AbstractProductA productA = factory.CreateProductA();
78 AbstractProductB productB = factory.CreateProductB();
79 //TODO..
80 Console.ReadLine();
81 }
82 }
3)
优点: 与工厂方法类似
适用: 适合那些客户端的操作逻辑与具体哪一系列产品无关的操作,她隔离了系列产品的创建和产品操作逻辑.所以可以使得不同系列的产品复用相同的操作逻辑.
tips: 可以用反射注入,这样在换系列产品的时候无需修改客户端代码.
3.建造者模式
1)简介: 通过一个构造器接口,让子类去实现具体的构造方法和逻辑,利用构造器接口去向客户端屏蔽目标对象具体的构造过程.同时,可以通过添加新的构造者去添加产生不同构造的目标对象(由于面向接口编程,所以客户端不知道这一变化).
2)结构图:
3)代码:
View Code
1 /// 构造者接口
2 public interface IBuilder
3 {
4 /// <summary></summary>
5 void BuildPart1();
6 /// <summary></summary>
7 void BuildPart2();
8 /// <summary></summary>
9 void BuildPart3();
10 /// <summary></summary>
11 Product GetProduct();
12 }
13
14 /// 具体构造者A,即含不同的构造逻辑
15 public class BuilderA : IBuilder
16 {
17 //组合Product,实现对Product的不同部分的构造
18 private Product _product;
19
20 public BuilderA()
21 {
22 _product = new Product();
23 }
24
25 /// 对Part1进行逻辑操作
26 public void BuildPart1()
27 {
28 //TODO
29 _product.Part1 = new object();
30 }
31 /// <summary></summary>
32 public void BuildPart2()
33 {
34 //TODO
35 }
36 /// <summary></summary>
37 public void BuildPart3()
38 {
39 //TODO
40 }
41 /// <summary></summary>
42 public Product GetProduct()
43 {
44 return _product;
45 }
46 }
47
48 /// 具体构造者B,即含不同的构造逻辑
49 public class BuilderB : IBuilder
50 {
51 //组合Product,实现对Product的不同部分的构造
52 private Product _product;
53
54 public BuilderB()
55 {
56 _product = new Product();
57 }
58
59 /// 对Part1进行逻辑操作
60 public void BuildPart1()
61 {
62 //TODO
63 _product.Part1 = new object();
64 }
65 /// <summary></summary>
66 public void BuildPart2()
67 {
68 //TODO
69 }
70 /// <summary></summary>
71 public void BuildPart3()
72 {
73 //TODO
74 }
75 /// <summary></summary>
76 public Product GetProduct()
77 {
78 return _product;
79 }
80 }
81
82 /// 目标产品
83 public class Product
84 {
85 public object Part1 { get; set; }
86 public object Part2 { get; set; }
87 public object Part3 { get; set; }
88
89 }
90
91 /// 控制着构造者构造Product的过程,同时起到对客户端隔离了Product的构造过程.
92 public class Manager
93 {
94 /// 根据不同的Builder来构造
95 public void Construct(IBuilder builder)
96 {
97 builder.BuildPart1();
98 builder.BuildPart2();
99 builder.BuildPart3();
100 //这里还可以控制构造Product的部分,比如构造其中的某几个部分
101 }
102 }
103
104 class Program
105 {
106 static void Main(string[] args)
107 {
108 Manager manager = new Manager();
109 IBuilder bA = new BuilderA();
110 IBuilder bB = new BuilderB();
111
112 //根据要求不同要求去构造Product
113 manager.Construct(bA);
114 Product pA = bA.GetProduct();
115
116 manager.Construct(bB);
117 Product pB = bB.GetProduct();
118
119 //TODO..
120
121 Console.ReadLine();
122 }
123 }
4)
适用: 适用于目标对象构造比较复杂,或者构造过程可能变化的时候.
4.原型模式
1)简介:
用一个原型类的实例去创建一个新的对象,这个新的对象是由原实例对象拷贝过来的(相当于将原对象复制一份生成)
2)结构图:
3)代码:
View Code
1 /// 原型
2 public abstract class Prototype
3 {
4 //tips:抽象类也是有构造函数的,因为他要被人继承,其子类实例化过程也是和普通类一样,先从最根处向下实例化
5 public Prototype(string member)
6 {
7 this.member1 = member;
8 }
9
10 protected string member1;
11
12 /// <summary></summary>
13 public abstract Prototype Clone();
14 }
15
16 /// 原型A
17 public class PrototypeA : Prototype
18 {
19 protected string member2;
20 public string Member2 { get { return member2;} }
21
22 public PrototypeA(string member1,string member2)
23 : base(member1)
24 {
25 this.member2 = member2;
26 }
27
28 /// 克隆实例对象自身(包括父类)
29 public override Prototype Clone()
30 {
31 //C#的话可以采用这种浅复制
32 return (Prototype)this.MemberwiseClone();
33
34 //若是其他语言没有类似语言则先new个对象,再将值赋进去,然后return这个对象
35 }
36 }
37
38
39 /// 原型B
40 public class PrototypeB : Prototype
41 {
42 /// <summary></summary>
43 public override Prototype Clone()
44 {
45 }
46 }
47
48 /// 原型AA
49 public class PrototypeAA : PrototypeA
50 {
51 protected string member3;
52 public string Member3 { get { return member3; } }
53
54 public PrototypeAA(string member1, string member2, string member3)
55 : base(member1, member2)
56 {
57 this.member3 = member3;
58 }
59
60 /// /// 克隆实例对象自身(包括父类)
61 public override Prototype Clone()
62 {
63 //C#的话可以采用这种浅复制
64 return (Prototype)this.MemberwiseClone();
65
66 //若是其他语言没有类似语言则先new个对象,再将值赋进去,然后return这个对象
67 }
68 }
69
70 class Program
71 {
72 static void Main(string[] args)
73 {
74 PrototypeA PA = new PrototypeA("m1", "m2");
75 PrototypeA PA2 = (PrototypeA)PA.Clone();
76 Console.Write(PA2.Member2);
77
78 PrototypeAA PAA = new PrototypeAA("m1", "m2", "m3");
79 PrototypeAA PAA2 = (PrototypeAA)PAA.Clone();
80 Console.Write(PAA2.Member3);
81
82 //TODO
83 Console.ReadLine();
84 }
85 }
4)适用:
适用于需要生成的对象具有父类实例对象的特性(着重点在于是实例对象,即运行时对象),即想让生成对象要具有和某一对象相同的属性,则可考虑采用原型模式(通常需要目标类是原类的子类或后代且都拥有Clone方法,后代重写Clone方法去复制自身对象实例)
5.单例模式
1）简介:
保证一个类仅有一个实例,并提供一个访问它的全局访问点.为了保证实例对象的唯一性,让类自身负责保存它的唯一实例.通常做法是1.私有化类构造方法(隔离外部访问) 2.提供一个公共的静态化生成实例方法(保证有唯一访问点)
2)结构图:
3)代码:
View Code
1 /// 单例
2 class Singleton
3 {
4 private static Singleton _instance;
5
6 private Singleton() { }
7
8 public static Singleton GetInstance(){
9 return _instance == null ? _instance=new Singleton() : _instance;
10 }
11
12 }
13
14 class Program
15 {
16 static void Main(string[] args)
17 {
18
19 Singleton s1 = Singleton.GetInstance();
20 Singleton s2 = Singleton.GetInstance();
21
22 //生成实例是同一个
23 Console.Write(s1 == s2);
24 //TODO
25 Console.ReadLine();
26 }
27 }
4)适用:
要求某个类在全局条件下只生成一个实例对象.
