工厂模式
工厂模式：建立创建对象的工厂
在面向对象编程中，术语“工厂”表示一个负责创建其他类型对象的类。通常情况下，作为一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法之后，工厂会据此创建所需类型的对象，然后将它们返回给客户端。
工厂具有下列优点：松耦合，即对象的创建可以独立于类的实现；客户端无需了解创建对象的类，但是照样可以使用它来创建对象。它只需要知道需要传递的接口、方法和参数，就能够创建 所需类型的对象了。这简化了客户端的实现；可以轻松地在工厂中添加其他类来创建其他类型的对象，而这无需更改客户端代码。最简单的情况下，客户端只需要传递一个参数就可以了；工厂还可以重用现有对象。但是，如果客户端直接创建对象的化，总是创建一个新对象。
Factory模式有3种变体：
（1）简单工厂模式： 允许接口创建对象，但不会暴露对象的创建逻辑。
（2）工厂方法模式：允许接口创建对象，但使用哪个类来创建对象，则是交由子类决定的。
（3）抽象工厂模式：抽象工厂是一个能够创建一系列相关的对象而无需指定/公开其具体类的接口。该模式能够提供其他工厂的对象，在其内部创建其他对象。
一、简单工厂模式
工厂可以帮助开发人员创建不同类型的对象，而不是直接将对象实例化。
简单工厂模式叫静态工厂方法模式，是由一个工厂对象决定创建出哪一种产品类的实例。
简单工厂模式就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例，涉及到工厂角色、抽象产品角色以及具体产品角色。
1 工厂类角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑关系。工厂类在客户端直接调用下创建产品对象，它往往由一个具体Java类实现。
2 抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或它们共同拥有的接口。抽象产品角色可以用一个Java接口或者Java抽象类实现。
3 具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体Java类实现。
实现：在下面的代码段中，我们将创建一个名为Animal的抽象产品。Animal是一个抽象的基类(ABCMeta是 Python的特殊元类，用来生成类Abstract)，它带有方法do_say()。我们利用Animal接口创建了两种产品（Cat和Dog），并实现了do_say()方法来提供这些动物的相应的叫声。ForestFactory是一个带有make_sound()方法的工厂。根据客户端传递的参数类型，它就可以在运行时创建适当的Animal实例，并输出正确的声音：
from abc import ABCMeta, abstractmethod
#抽象类
class Animal(metaclass = ABCMeta):
@abstractmethod
def do_say(self):
pass
class Dog(Animal):
def do_say(self):
print('汪汪。。。')
class Cat(Animal):
def do_say(self):
print('喵喵。。。')
#工厂类：
class ForestFactory:
def make_sound(self, object_type):
return eval(object_type)().do_say()
#client code
if __name__ == '__main__':
ff = ForestFactory()
animal = input('Which animal should make sound(Dog or Cat)?')
ff.make_sound(animal)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
##二、工厂方法模式
以下几点可以帮助我们了解工厂方法模式：
（1）我们定义了一个接口来创建对象，但是工厂本身并不负责创建对象，而是将这以任务交由子类来完成，即子类决定了要实例化哪些类；
（2）Factory方法的创建是通过继承而不是通过实例化来完成的；
（3）工厂方法使设计更加具有可定制性。它可以返回相同的实例或子类，而不是某种类型的对象。
在UML图中，有一个包含factoryMethod()方法的抽象类Creator。factoryMethod()方法负责创建指定类型的对象。ConcreteCreator类提供了一个实现Creator抽象类的factoryMethod()方法，这种方法可以在运行是时修改已创建的对象。ConcreteCreator创建ConcreteProduct，并确保其创建的对象实现了Product类，同时为Product接口中的所有方法提供相应的实现。
简而言之，Creator接口的factoryMethod()方法和ConcreteCreator类共同决定了要创建Product的哪个子类。因此，工厂方法模式定义了一个接口来创建对象，但具体实例化哪个类则是由它的子类决定的。
from abc import ABCMeta, abstractmethod
#抽象Product
class Section(metaclass = ABCMeta):
@abstractmethod
def describe(self): #抽象方法
pass
#ConcreteProduct1
class PersonalSection(Section):
def describe(self):
print('Personal Section!')
#ConcreteProduct2
class AlbumSection(Section):
def describe(self):
print('Album Section!')
#ConcreteProduct3
class PatentSection(Section):
def describe(self):
print('Patent Section!')
#ConcreteProduct4
class PublicationSection(Section):
def describe(self):
print('Publication Section!')
#抽象类Creator
class Profile(metaclass = ABCMeta):
def __init__(self):
self.sections = []
self.createProfile()
@abstractmethod
def createProfile(self):
pass
def getSections(self):
return self.sections
def addSectons(self, section):
self.sections.append(section)
#ConcreteCreator类
class linkedin(Profile):
def createProfile(self):
self.addSectons(PersonalSection())
self.addSectons(PatentSection())
self.addSectons(PublicationSection())
#ConcreteCreator类
class facebook(Profile):
def createProfile(self):
self.addSectons(PersonalSection())
self.addSectons(AlbumSection())
if __name__ == '__main__':
profile_type = input('Which Profile you\'d like to create?(LinkedIn or FaceBook)')
profile = eval(profile_type.lower())() #实例化类
print('Creating Profile...:', type(profile).__name__)
print('Profile has sections...:', profile.getSections())
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
工厂方法模式的优点：
（1）它具有更大的灵活性，使得代码更加通用，因为它不是单纯地实例化某个类。这样，实现哪些类取决于接口（Product），而不是ConcreteCreator。
（2）它们是松耦合的，因为创建对象的代码与使用它的代码是分开的。客户端完全不需要关心要传递哪些参数以及需要实例化哪些类。由于添加新类更加容易，所以降低了维护成本。
##三、抽象工厂模式
抽象工厂模式的主要目的是提供一个接口来创建一系列相关对象，而无需指定具体的类。工厂方法将创建实例的任务委托给了子类，而抽象工厂方法的目标是创建一系列相关对象。如图3所示，ConcreteFactory1 和 ConcreteFactory2 是通过AbstractFactory接口创建的。此接口具有创建多种产品的相应方法。
ConcreteFactory1 和 ConcreteFactory2实现了AbstractFactory，并创建实例ConcreteProduct1、ConcreteProduct2、AnotherConcreteProduct1和AnotherConcreteProduct2。
在这里，ConcreteProduct1和ConcreteProduct2是通过AbstractProduct接口创建的，而AnotherConcreteProduct1和AnotherConcreteProduct2则是通过AnotherAbstractProduct接口创建的。
实际上，抽象工厂模式不仅确保客户端与对象的创建相互隔离，同时还确保客户端能够使用创建的对象。但是，客户端只能通过接口访问对象。如果要使用一个系列中的多个产品，那么抽象工厂模式能够帮助客户端一次使用来自一个产品/系列的多个对象。
###实现抽象工厂模式
例子：一家披萨店，供应印式和美式披萨饼。为此，我们首先创建一个抽象基类—PizzaFactory（AbstractFactory）。PizzaFactory类有两个抽象方法即createVegPizza()和createNonVegPizza()，它们需要通过ConcreteFactory实现。在这个例子中，我们创建了两个具体的工厂，分别名为IndianPizzaFactory和USPizzaFactory。
from abc import ABCMeta, abstractmethod
#AbstractFactory
class PizzaFactory(metaclass = ABCMeta):
@abstractmethod
def createVegPizza(self):
pass
@abstractmethod
def createNonVegPizza(self):
pass
#ConcreteFactory
class IndianPizzaFactory(PizzaFactory):
def createVegPizza(self):
return DeluxVeggiePizza()
def createNonVegPizza(self):
return ChickenPizza()
#ConcreteFactory
class USPizzaFactory(PizzaFactory):
def createVegPizza(self):
return MexicanVegPizza()
def createNonVegPizza(self):
return HamPizza()
#进一步定义 AbstractProducts:
#AbstractProduct
class VegPizza(metaclass = ABCMeta):
@abstractmethod
def prepare(self, VegPizza): #定义自己的方法
pass
#AnotherAbstractProduct
class NonVegPizza(metaclass = ABCMeta):
@abstractmethod
def serve(self, VegPizza): #定义自己的方法
pass
#为每个AbstractProducts定义ConcreteProducts,创建DeluxVeggiePizza和MexicanVegPizza:
class DeluxVeggiePizza(VegPizza): #ConcreteProducts1
def prepare(self):
print('Prepare:', type(self).__name__)
#定义AnotherConcreteProduct：
class MexicanVegPizza(VegPizza): #ConcreteProducts2
def prepare(self):
print('Prepare:', type(self).__name__)
#定义ChickenPizza和HamPizza,分别代表AnotherConcreteProducts1和AnotherConcreteProducts2：
class ChickenPizza(NonVegPizza): #AnotherConcreteProducts1
def serve(self, VegPizza):
print(type(self).__name__, ' is served with Chicken on ', type(VegPizza).__name__)
class HamPizza(NonVegPizza):
def serve(self, VegPizza):
print(type(self).__name__, ' is served with Ham on ', type(VegPizza).__name__)
#当最终用户来到PizzaStore并要一份美式非素食披萨的时候，USPizzaFactory负责准备素食，
#然后在上面加上火腿，马上就变成非素食披萨了：
class PizzaStore:
def __init__(self):
pass
def makePizzas(self):
for factory in [IndianPizzaFactory(), USPizzaFactory()]:
self.factory = factory
self.NonVegPizza = self.factory.createNonVegPizza()
self.VegPizza = self.factory.createVegPizza()
self.VegPizza.prepare()
self.NonVegPizza.serve(self.VegPizza)
if __name__ == '__main__':
pizza = PizzaStore()
pizza.makePizzas()
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
###工厂方法与抽象工厂方法
工厂方法 抽象工厂方法
它向客户端开发了一个创建对象的方法 抽象工厂方法包含一个或多个工厂方法来创建一个系列的相关对象
它使用继承和子类来决定要创建哪个对象 它使用组合将创建对象的任务委托给其他类
工厂方法用于创建一个产品 抽象工厂方法用于创建相关产品的系列
————————————————
原文链接：https://blog.csdn.net/weixin_38853600/article/details/82586557
