设计模式- 创建型模式

1. 单例模式
定义: 一个类只有一个实例,并提供一个全局访问点
特点：
a. 单例类只能有一个实例。
b. 单例类必须自己创建自己的唯一实例。
c. 单例类必须给所有其它对象提供这一实例。
应用场景:
线程池、缓存、日志、文件等对象都只需要创建一个对象
优点：节约资源不需要创建多的实例
缺点：1.单例中没有抽象的类，无法实现扩展
2.职责过重，违背了"单一职责原则"
c# 代码实现:

 1    /// <summary>
 2     /// 文件管理器
 3     /// </summary>
 4     public class FileManager
 5     {
 6         /// <summary>
 7         /// 锁的静态对象
 8         /// </summary>
 9         private static readonly object _locker = new object();
10 
11         /// <summary>
12         /// 对象实例
13         /// </summary>
14         private FileManager _fileManager = null;
15 
16         /// <summary>
17         /// 构造函数
18         /// </summary>
19         private FileManager()
20         { 
21             
22         }
23 
24         /// <summary>
25         /// 获取实例(全局访问点)
26         /// </summary>
27         /// <returns></returns>
28         public FileManager GetInstance()
29         {
30             if (_fileManager == null)
31             {
32                 //加锁
33                 lock (_fileManager)
34                 {
35                     if (_fileManager == null)
36                     {
37                         _fileManager = new FileManager();
38                     }
39                 }
40             }
41             return _fileManager;
42         }
43 
44     }

View Code

2. 简单工厂模式
定义:负责生产对象的一个类
适用场景：
1. 工厂类负责创建的对象比较少
2. 客户端只需要知道传入工厂的参数，对于如何创建无需关心
优点:只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节
缺点:工厂类的职责过多,增加产品需要修改原来类的代码，违背开闭原则
c# 代码实现：

 1     /// <summary>
 2     /// 食物
 3     /// </summary>
 4     public abstract class Food
 5     {
 6         /// <summary>
 7         /// 打印当前菜名称
 8         /// </summary>
 9         public abstract void Print();
10     }
11 
12     /// <summary>
13     /// 土豆丝
14     /// </summary>
15     public class ShreddedPorkWithPotatoes : Food
16     {
17         /// <summary>
18         /// 打印
19         /// </summary>
20         public override void Print()
21         {
22             Console.WriteLine("土豆肉丝！");
23         }
24     }
25 
26     /// <summary>
27     /// 西红柿炒鸡蛋
28     /// </summary>
29     public class TomatoScrambledEggs : Food
30     {
31         /// <summary>
32         /// 打印
33         /// </summary>
34         public override void Print()
35         {
36             Console.WriteLine("一份西红柿炒蛋！");
37         }
38     }
39 
40 
41     /// <summary>
42     /// 饭店(食物工厂)
43     /// </summary>
44     public class FoodFactory
45     {
46         /// <summary>
47         /// 创建食物 【如果出现新的菜 必须要在该类中添加-破坏了开闭原则】
48         /// </summary>
49         /// <param name="type"></param>
50         /// <returns></returns>
51         public static Food CreateFood(string type)
52         {
53             Food food = null;
54             if (type.Equals("土豆肉丝"))
55             {
56                 food = new ShreddedPorkWithPotatoes();
57             }
58             else if (type.Equals("西红柿炒蛋"))
59             {
60                 food = new TomatoScrambledEggs();
61             }
62             return food;
63         }
64     }

View Code

3. 工厂方法模式
定义：工厂类不负责具体产品的创建,只是给出具体工厂必须实现的接口
工厂方法模式适用场景 :
重复代码,创建对象需要使用大量重复的代码 ;
不关心创建过程 : 客户端不依赖产品类,不关心实例如何被创建,实现等细节 ;
创建对象,一个类通过其子类来指定创建哪个对象;
优点: 不关心创建细节,用户只需要关心所需产品对应的工厂,无需关心创建细节 ;
符合开闭原则 :加入新产品 ,符合开闭原则 ,提高可扩展性 ;
缺点:增加复杂性 : 类的个数容易过多 , 增加系统复杂度 ;
在添加新产品时 , 除了编写新的产品类之外 , 还要编写该产品类对应的工厂类 ;
增加难度 : 增加了系统抽象性和理解难度 ;
工厂方法本身利用了抽象,该模式中会引入抽象层 ,如果要动态创建产品类 ,还要引入反射技术 ;
c#代码实现：

 1     /// <summary>
 2     /// 形状
 3     /// </summary>
 4     public abstract class Shape
 5     {
 6 
 7         public abstract void Draw();
 8     }
 9 
10     /// <summary>
11     /// 圆
12     /// </summary>
13     public class Circle : Shape
14     {
15         public override void Draw()
16         {
17             Console.WriteLine("绘制圆");
18         }
19     }
20 
21 
22     public class Rectangle : Shape
23     {
24         /// <summary>
25         /// 绘制
26         /// </summary>
27         public override void Draw()
28         {
29             Console.WriteLine("绘制矩形");
30         }
31     }
32 
33 
34     /// <summary>
35     /// 
36     /// </summary>
37     public abstract class ICreator
38     {
39         /// <summary>
40         /// 获取形状
41         /// </summary>
42         /// <returns></returns>
43        public abstract Shape GetShape();
44     }
45 
46     /// <summary>
47     /// 西红柿炒蛋工厂类
48     /// </summary>
49     public class CircleFactory :ICreator
50     {
51 
52         /// <summary>
53         /// 获取形状
54         /// </summary>
55         /// <returns></returns>
56         public override Shape GetShape()
57         {
58             return new Circle();
59         }
60     }
61 
62     /// <summary>
63     /// 矩形工厂
64     /// </summary>
65     public class RectangeFactory : ICreator
66     {
67         /// <summary>
68         /// 获取形状
69         /// </summary>
70         /// <returns></returns>
71         public override Shape GetShape()
72         {
73             return new Rectangle();
74         }
75     }

View Code

4. 抽象工厂模式
定义：提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明确指定具体类
适用场景:
一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
这个系统有多个系列产品，而系统中只消费其中某一系列产品
系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。
成熟产品分店模式

优点:抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，
这样更有利于后期的维护和扩展，这真是抽象工厂模式的优点所在
缺点:抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则
C#代码实现:

  1     /// <summary>
  2     /// 
  3     /// </summary>
  4     public abstract class YaBo
  5     {
  6         public abstract void Print();
  7     }
  8 
  9     /// <summary>
 10     /// 
 11     /// </summary>
 12     public abstract class YaJia
 13     {
 14         public abstract void Print();
 15     }
 16 
 17     /// <summary>
 18     /// 
 19     /// </summary>
 20     public class WuhanYabo : YaBo
 21     {
 22         public override void Print()
 23         {
 24             Console.Write("武汉鸭脖");
 25         }
 26     }
 27 
 28     /// <summary>
 29     /// 
 30     /// </summary>
 31     public class WuhanYajia : YaJia
 32     {
 33         public override void Print()
 34         {
 35             Console.Write("武汉鸭架");
 36         }
 37     }
 38 
 39     /// <summary>
 40     /// 上海鸭脖
 41     /// </summary>
 42     public class ShangHaiYabo : YaBo
 43     {
 44         public override void Print()
 45         {
 46             Console.Write("上海鸭脖");
 47         }
 48     }
 49 
 50     /// <summary>
 51     /// 上海鸭架
 52     /// </summary>
 53     public class ShangHaiYaJia : YaJia
 54     {
 55         public override void Print()
 56         {
 57             Console.Write("上海鸭架");
 58         }
 59     }
 60 
 61 
 62 
 63     /// <summary>
 64     /// 抽象工厂
 65     /// </summary>
 66     public abstract class AbstractFactory
 67     {
 68         /// <summary>
 69         ///  创建鸭脖
 70         /// </summary>
 71         /// <returns></returns>
 72         public abstract YaBo CreateYabo();
 73 
 74         /// <summary>
 75         ///  创建鸭架
 76         /// </summary>
 77         /// <returns></returns>
 78         public abstract YaJia CreateYaJia();
 79     }
 80 
 81 
 82     /// <summary>
 83     /// 武汉鸭工厂
 84     /// </summary>
 85     public class WuhanFactory : AbstractFactory
 86     {
 87         /// <summary>
 88         /// 鸭脖
 89         /// </summary>
 90         /// <returns></returns>
 91         public override YaBo CreateYabo()
 92         {
 93             return new WuhanYabo();
 94         }
 95 
 96         /// <summary>
 97         /// 鸭架
 98         /// </summary>
 99         /// <returns></returns>
100         public override YaJia CreateYaJia()
101         {
102             return new WuhanYajia();
103         }
104     }
105 
106 
107     /// <summary>
108     /// 上海鸭工厂
109     /// </summary>
110     public class ShanghaiFactory : AbstractFactory
111     {
112         /// <summary>
113         /// 鸭脖
114         /// </summary>
115         /// <returns></returns>
116         public override YaBo CreateYabo()
117         {
118             return new ShangHaiYabo();
119         }
120 
121         /// <summary>
122         /// 鸭架
123         /// </summary>
124         /// <returns></returns>
125         public override YaJia CreateYaJia()
126         {
127             return new ShangHaiYaJia();
128         }
129     }

View Code

5. 建造者模式
定义:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
适用场景:
当一些对象的基本属性经常性进行组合适用的时候

优点:
建造代码与表示代码的分离，可以使客户端不必知道产品内部组成的细节，从而降低了客户端与具体产品之间的耦合度
c# 代码实现:

 1     /// <summary>
 2     /// 产品
 3     /// </summary>
 4     public class Computer
 5     {
 6         /// <summary>
 7         /// 电脑所有零件
 8         /// </summary>
 9         public IList<string> _parts = new List<string>();
10 
11         /// <summary>
12         /// 添加
13         /// </summary>
14         /// <param name="part"></param>
15         public void Add(string part)
16         {
17             _parts.Add(part);
18         }
19 
20         /// <summary>
21         /// 展示组件
22         /// </summary>
23         public void Show()
24         {
25             foreach (string part in _parts)
26             {
27                 Console.WriteLine("组件" + part + "已装好");
28             }
29         }
30     }
31 
32     /// <summary>
33     /// 建造者
34     /// </summary>
35     public abstract class Builder
36     {
37         public Computer _computer = new Computer();
38 
39         public abstract void BuildMainBoard();
40 
41         public abstract void BuildCpu();
42     }
43 
44 
45     /// <summary>
46     /// 实际构造者
47     /// </summary>
48     public class BuilderA : Builder
49     {
50         /// <summary>
51         /// 构建cpu
52         /// </summary>
53         public override void BuildCpu()
54         {
55             _computer.Add("Cpu");
56         }
57 
58         public override void BuildMainBoard()
59         {
60             _computer.Add("Main Board");
61         }
62     }
63 
64 
65     /// <summary>
66     /// 指挥者角色
67     /// </summary>
68     public class Director
69     {
70         /// <summary>
71         /// 构建电脑
72         /// </summary>
73         /// <param name="builder"></param>
74         public void Build(Builder builder)
75         {
76             builder.BuildMainBoard();
77             builder.BuildCpu();
78         }
79     }

View Code

6. 原型模式
定义:通过克隆(Clone),通过已经存在的，将其复制而产生新的
适用场景：
创建一个类的实例的过程很昂贵或很复杂，并且我们需要创建多个这样类的实例时

优点：
1.原型模式向客户隐藏了创建新实例的复杂性
2.原型模式允许动态增加或较少产品类。
3.原型模式简化了实例的创建结构，工厂方法模式需要有一个与产品类等级结构相同的等级结构，而原型模式不需要这样。
4.产品类不需要事先确定产品的等级结构，因为原型模式适用于任何的等级结构
缺点:
1.每个类必须配备一个克隆方法
2.配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
c#代码实现：

 1     /// <summary>
 2     /// 圆形原型
 3     /// </summary>
 4     public abstract class CirclePrototype
 5     {
 6         /// <summary>
 7         /// 半径
 8         /// </summary>
 9         public double Radius { get; set; }
10 
11 
12         public abstract void Draw();
13 
14         public abstract CirclePrototype Clone();
15     }
16 
17     /// <summary>
18     /// 具体圆
19     /// </summary>
20     public class ConcreteCircle : CirclePrototype
21     {
22 
23         /// <summary>
24         /// 绘制圆
25         /// </summary>
26         public override void Draw()
27         {
28 
29         }
30 
31         /// <summary>
32         /// 浅拷贝 【可以实现深拷贝】
33         /// </summary>
34         /// <returns></returns>
35         public override CirclePrototype Clone()
36         {
37             return this.MemberwiseClone() as CirclePrototype;
38         }
39     }