设计模式之抽象工厂

抽象工厂模式结构图

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

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。

抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工程又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式

产品族：一个工厂类生产出的产品属于一个产品族，视作具体工厂类生产出来的具体产品类
产品等级：不同工厂类的同一个产品等级，产品等级可以视作继承抽象工厂类的工厂类

手机、电脑两种产品，有华为和苹果两个工厂，两个工厂都可以生产手机和电脑；

1、手机和电脑两种产品，定义两个接口
2、华为和苹果都可以生产者手机和电脑，所以有4个实现类；
3、需要创建华为和苹果的工厂类，先将工厂类进行抽象，里面有创建两个产品的方法，返回的是产品的接口类
4、创建华为和苹果的工厂实现类，继承工厂类接口，实现创建各自产品的方法
5、客户端调用时，直接用工厂接口类创建需要的工厂，拿到对应的产品

 class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("----------华为工厂----------");
            IProductFactory huaweiFactory = new HuaweiFactory();//创建华为工厂
           

            //生产华为手机
            IPhoneProduct huaweiPhone = huaweiFactory.phoneProduct();
            huaweiPhone.Show();
            huaweiPhone.Open();

            //生产华为电脑
            IComputerProduct huaweicomputer = huaweiFactory.computerProduct();
            huaweicomputer.Show();
            huaweicomputer.Open();



            Console.WriteLine("----------苹果工厂----------");
            IProductFactory appleFactory = new AppleFactory();//创建苹果工厂

            //生产苹果手机
            IPhoneProduct applePhone = appleFactory.phoneProduct();
            applePhone.Show();
            applePhone.Open();

            //生产苹果电脑
            IComputerProduct applecomputer = appleFactory.computerProduct();
            applecomputer.Show();
            applecomputer.Open();


            Console.ReadLine();

        }
    }

    //手机产品接口
    public interface IPhoneProduct
    {
        public  void Open()
        {
            Console.WriteLine("开机");
        }
        public  void Close()
        {
            Console.WriteLine("关机");
        }
        public  void Show()
        {
            Console.WriteLine("我是手机");
        }
    }

    //华为手机
    public class HuaweiPhone:IPhoneProduct
    {
        public  void Open()
        {
            Console.WriteLine("华为手机开机");
        }
        public void Close()
        {
            Console.WriteLine("华为手机关机");
        }
        public void Show()
        {
            Console.WriteLine("我是华为手机");
        }

    }
    //苹果手机
    public class ApplePhone : IPhoneProduct
    {
        public void Open()
        {
            Console.WriteLine("苹果手机开机");
        }
        public void Close()
        {
            Console.WriteLine("苹果手机关机");
        }
        public void Show()
        {
            Console.WriteLine("我是苹果手机");
        }
    }


    //电脑产品接口
    public interface IComputerProduct
    {
        public void Open()
        {
            Console.WriteLine("电脑开机");
        }
        public void Close()
        {
            Console.WriteLine("电脑关机");
        }
        public void Show()
        {
            Console.WriteLine("我是电脑");
        }

    }

    //华为电脑
    public class HuaweiComputer:IComputerProduct
    {
        public void Open()
        {
            Console.WriteLine("华为电脑开机");
        }
        public void Close()
        {
            Console.WriteLine("华为电脑关机");
        }
        public void Show()
        {
            Console.WriteLine("我是华为电脑");
        }
    }
    //苹果电脑
    public class AppleComputer:IComputerProduct
    {
        public void Open()
        {
            Console.WriteLine("苹果电脑开机");
        }
        public void Close()
        {
            Console.WriteLine("苹果电脑关机");
        }
        public void Show()
        {
            Console.WriteLine("我是苹果电脑");
        }

    }


    //抽象工厂类
    public interface IProductFactory
    {
        //生产手机
        IPhoneProduct phoneProduct();

        //生产电脑
        IComputerProduct computerProduct();
    }


    //华为工厂实现类
    public class HuaweiFactory : IProductFactory
    {
        public IComputerProduct computerProduct()
        {
            return new HuaweiComputer();
        }

        public IPhoneProduct phoneProduct()
        {
            return new HuaweiPhone();
        }
    }

    //苹果工厂实现类

    public class AppleFactory : IProductFactory
    {
        public IComputerProduct computerProduct()
        {
            return new AppleComputer();
        }

        public IPhoneProduct phoneProduct()
        {
            return new ApplePhone();
        }
    }
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

抽象工厂模式的优缺点
优点：一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象(将一个系列的产品统一一起创建)

缺点：
产品族扩展非常困难，要增加一个系列的某一产品，既要修改工厂抽象类里加代码，又修改具体的实现类里面加代码；
增加了系统的抽象性和理解难度

适用场景

1、一系列相关产品对象(属于同一产品族)一起创建时需要大量的重复代码
2、提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

抽象工厂模式符合依赖抽象原则
创建对象实例时，不要直接new 一个对象，而是把创建对象的动作放在一个工厂的方法中
不要让类继承具体类，而是继承抽象类或者是实现接口。
不要覆盖基类中以及实现的方法