设计模式速查版创建型

创建型模式用来处理对象的创建过程，主要包含以下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     }

优点: 工厂方法使得一个类的实例化延迟到其子类.

适用: 客户端的加工逻辑只需要知道是哪类产品,而不需知道具体的产品名.这样不同的产品就可以复用相同的加工逻辑.

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     }

优点: 与工厂方法类似

适用: 适合那些客户端的操作逻辑与具体哪一系列产品无关的操作,她隔离了系列产品的创建和产品操作逻辑.所以可以使得不同系列的产品复用相同的操作逻辑.

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

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)适用:

要求某个类在全局条件下只生成一个实例对象.

设计模式速查版 创建型

1.工厂方法

2.抽象工厂

3.建造者模式

4.原型模式

5.单例模式

设计模式速查版创建型