一、几种常用的设计模式_接口设计模式

设计模式分类

• 创建者模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。
  常用：单例模式、工厂方法模式、抽象工厂模式、建造者模式 。
  不常用：原型模式
• 结构型模式：把类或对象结合在一起形成一个更大的结构。
  常用：代理模式、桥接模式、装饰者模式、适配器模式。
  不常用：组合模式、外观模式、享元模式。
• 行为型模式：类和对象如何交互、划分责任和算法。
  常用：观察者模式、模板模式、策略模式、责任链模式、迭代器模式、状态模式。
  不常用：访问者模式、备忘录模式、命令模式、解释器模式、中介模式。
  

各分类中模式的关键点

• 单例模式：某个类只能有一个实例，并且提供一个全局的访问点。
• 简单工厂：一个工厂类根据传入的参数决定创建出那一种产品类的实例。
• 工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。
• 抽象工厂：创建相关或依赖对象的家族，而无须明确指定具体类。
• 建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。
• 原型模式：通过复制现有的实例来创建新的实例。
• 适配器模式：将一个类的方法接口转换成客户希望的另一个接口。
• 组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。
• 装饰模式：动态的给对象添加新的功能。
• 代理模式：为其它对象提供一个代理以便控制这个对象的访问。
• 享元模式：通过共享技术来有效的支持大量细粒度的对象。
• 外观模式：对外提供一个同一的方法，来访问子系统中的一群接口。
• 桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。
• 模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。
• 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。
• 策略模式：定义一系列算法，把它们封装起来，并且使它们可以相互替换。
• 状态模式：允许一个对象在其对象内部状态改变时改变它的行为。
• 观察者模式：对象间的一对多的依赖关系。
• 备忘录模式：在不破坏封装的前提下，保持对象的内部状态。
• 中介者模式：用一个中介对象来封装一系列的对象交互。
• 命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。
• 访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。
• 责任链模式：将请求的发送者和接受者解耦，使得多个对象都有处理这个请求的机会。
• 迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。

设计模式详解

1、单例模式

单例模式，它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。

单例模式的特定：
1、只有一个实例。
2、自我实例化。
3、提供全局访问点。

单例模式的优点主要就是节约系统资源，提高系统效率，同时也能够严格控制客户对它的访问。
也许就是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，所以扩展起来有一定的困难。

单例模式实现方式
1、懒汉式单例：第一次被引用时，才会将自己实例化。
利用双重锁定解决多线程不安全的问题。

    class Singleton
    {
        private static Singleton instance;
        private static readonly object syncRoot = new object();
        //构造函数必须是私有，防止在类的外部被实例化
        private Singleton()
        {
        }
        public static Singleton GetInstance()
        {
        	//先判断实例是否存在，不存在再加锁处理
            if (instance == null)
            {
            	//再同一时刻加了锁的那部分程序只有一个线程可以进入
                lock (syncRoot)
                {
                	/*
                	如果当instance为null并且同时有两个线程调用GetInstance()方法时，
                	它们将都可以通过第一重instance==null的判断。然后由于lock机制，这两个线程则只有一个进入,
                	另一个在外排队等候，必须要其中的一个进入并出来后，另一个才能进入。而此时如果没有了第二重的
                	instance==null的判断，则第一个线程创建了实例，而第二线程还是可以继续在创建新的实例。
                	*/
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2、饿汉式单例：静态初始化的方式，是在自己被加载时就将自己实例化。
缺点：需要提前占用系统资源。

    public sealed class Singleton
    {
        private static readonly Singleton instance = new Singleton();
        private Singleton() { }
        public static Singleton GetInstance()
        {
            return instance;
        }
    }
1
2
3
4
5
6
7
8
9

2、工厂方法模式

工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。
同时在工厂方法模式中用户只需要知道生成产品的具体工厂即可，无须关心产品的创建过程。
虽然它很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类。这样就会导致系统的复杂度增加。

结构图

    class Program
    {
        static void Main(string[] args)
        {
            //工厂方法模式
            IFactory factory = new HUAWEIFactory ();
            Phone phone= factory.CreatePhone();

            phone.Bells();
            phone.Call();
            phone.Send();

            Console.Read();
        }
    }
    //手机对象类
    class Phone
    {
        public void Send()
        {
            Console.WriteLine("发短信");
        }

        public void Call()
        {
            Console.WriteLine("打电话");
        }

        public void Bells()
        {
            Console.WriteLine("闹铃");
        }
    }
    //华为（具体产品类）
    class HUAWEI: Phone 
    { }
    
    //小米（具体产品类）
    class XiaoMi: Phone 
    { }
    
     //手机工厂（创建手机对象的接口）
    interface IFactory
    {
        Phone CreatePhone();
    }
    
    //生产华为手机的工厂(具体产品工厂类)
    class HUAWEIFactory : IFactory
    {
        public Phone CreatePhone()
        {
            return new HUAWEI();
        }
    }
    
     //生产小米手机的工厂(具体产品工厂类)
    class XiaoMiFactory : IFactory
    {
        public Phone CreatePhone()
        {
            return new XiaoMi();
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

3、抽象工厂模式

• 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

  他允许客户端使用抽象的接口来创建一组相关的产品，而不需要关心实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了，而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更改接口及其下所有子类。
  （新增一个产品，就会增加抽象产品、具体产品类以及修改抽象工厂、具体工厂类）

• 组成角色

  角色	关系	作用
  抽象工厂（AbstractFactory）	具体工厂的父类	抽象工厂接口，它里面包含所有的产品创建的抽象方法
  具体工厂（ConcreteFactory）	抽象工厂的子类；被外界调用	实现抽象工厂方法，创建产品的实例
  抽象产品（AbstractProduct）	具体产品的父类	描述具体产品的公共接口
  具体产品（ConcreteProduct）	抽象产品的子类；工厂类创建的目标类	对抽象产品的具体分类实现

• 结构图
  

• 实现代码

    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();
            
            Console.Read();
        }
    }
    
    //抽象工厂类
    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }   
    
    //具体工厂类1；实现抽象工厂类方法
    class ConcreteFactory1 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }
	//具体工厂类2；实现抽象工厂类方法
    class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    } 
      
    //抽象产品A
    abstract class AbstractProductA
    {
    }
	//抽象产品B
    abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }  
    //具体产品A1
    class ProductA1 : AbstractProductA
    {
    }
    
	//具体产品B1
    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }
	//具体产品A2
    class ProductA2 : AbstractProductA
    {
    }
	//具体产品B2
    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    } 
    
    class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor 
        public Client(AbstractFactory factory)
        {
            AbstractProductB = factory.CreateProductB();
            AbstractProductA = factory.CreateProductA();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }       
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102