工厂模式
如有三类可以选择的外卖餐品：汉堡等主餐、小食、饮料。当我们选择好自己需要的食物，支付完成后，订单就生成了。
或者您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了，不需要知道其他详细信息。
2、作为调用者而言，屏蔽产品的具体实现，调用者只关心产品的接口
缺点：
1 当有新的类型要加入到系统中时，必须修改工厂类，加入必要的处理逻辑，这违背了“开闭原则”。
2 在简单工厂模式中，所有的产品都是由同一个工厂创建，工厂类职责较重，业务逻辑较为复杂，具体产品与工厂类之
间的耦合度高，严重影响了系统的灵活性和扩展性，
而工厂方法模式则可以很好地解决这一问题。
使用实例：
1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类， 共同实现一个接 口。
拓展： “开放-封闭原则”。即所谓的对扩展开放，对修改关闭
工厂方法模式（Factory Method Pattern）：相同接口生产不同系列产品，获取同一类型多个不同实例。
在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的时将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
即 使用相同的接口，来处理不同的事情。
不足：在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
# 工厂模式：
def create_shape(name):
if name =='Circle':
return Circle()
elif name == 'Rectangle':
return Rectangle()
elif name == 'Triangle':
return Triangle()
elif name == 'Ellipse':
return Ellipse()
else:
return None # 工厂方法模式：
import math
#定义4个图形类，并且每一个图形都有一个可以计算面积的方法
class Circle:
def Area(self,radius):
return math.pow(radius,2)*math.pi
class Rectangle:
def Area(self,longth,width):
return 2*longth*width
class Triangle:
def Area(self,baselong,height):
return baselong*height/2
class Ellipse:
def Area(self,long_a,short_b):
return long_a*short_b*math.pi
#定义创建对象的工厂接口，因为python中并没有接口的概念，所以，这里打算通过“类的继承”加以实现
class IFactory: #模拟接口
def create_shape(self): #定义接口的方法，只提供方法的声明，不提供方法的具体实现
pass
class CircleFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承
def create_shape(self, name): #重写接口中的方法
if name =='Circle':
return Circle()
class RectangleFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承
def create_shape(self, name): #重写接口中的方法
if name =='Rectangle':
return Rectangle()
class TriangleFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承
def create_shape(self, name): #重写接口中的方法
if name =='Triangle':
return Triangle()
class EllipseFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承
def create_shape(self, name): #重写接口中的方法
if name =='Ellipse':
return Ellipse()
if __name__=='__main__':
factory1=CircleFactory()
factory2=RectangleFactory()
factory3=TriangleFactory()
factory4=EllipseFactory()
circle=factory1.create_shape('Circle')
circle_area=circle.Area(2)
print(f'这是一个圆，它的面积是：{circle_area}')
rectangle=factory2.create_shape('Rectangle')
rectangle_area=rectangle.Area(2,3)
print(f'这是一个长方形，它的面积是：{rectangle_area}')
triangle=factory3.create_shape('Triangle')
triangle_area=triangle.Area(2,3)
print(f'这是一个三角形，它的面积是：{triangle_area}')
ellipse=factory4.create_shape('Ellipse')
ellipse_area=ellipse.Area(3,2)
print(f'这是一个椭圆，它的面积是：{ellipse_area}')
工厂模式：
针对一个系列的类（比如Circle、Rectangle、Ellipse、Triangle）,它们有很多的共同点，通俗的说就是一个系列的类。使用一个工厂，用一个工厂创建函数去创建某一个类。
一系列类——>一个工厂——>一个创建函数——>某一个具体的类
工厂方法模式：
针对一系列的类（比如Circle、Rectangle、Ellipse、Triangle），使用一个抽象的工厂接口，然后然后为每一个具体的类都编写一个工厂类，然后再在每一个类中用创建函数创建。
一系列类——>一个抽象工厂接口——>多个与系列对应的工厂类——>每个类有一个创建函数——>某一个具体的类
总结：简单工厂模式是笼统的承包服务，不管有多少个类需要创建，全部都由一个工厂去完成；
工厂函数模式是定制化的一对一服务，每一个工厂只能创建某一种特定的类，但是这些工厂统一遵循总工厂指定的原则
（即抽象工厂接口的创建方法）。
那什么又是抽象工厂模式？
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
简单工厂模式：集中式生产
工厂方法模式：分散式成产
抽象工厂模式：对于同一系列的集中式生产，对于不同系列的分散式生产（就是前二者的结合）
工厂方法与抽象工厂方法的比较
工厂方法开发了一个创建对象的方法
抽象工厂方法开放了一个或者多个方法创建一个系列的相关对象
工厂方法使用继承和子类来决定要创建哪个对象
抽象共产方法使用组合将创建对象的任务委托给其他类
共产方法用于创建一个产品
抽象工厂方法用于创建相关产品的系列
参考“四步走”策略完整实现抽象工厂模式（https://blog.csdn.net/qq_27825451/article/details/84284681）
import math
#定义一个“形状”的接口，里面定义一个面积的接口方法，只有方法的定义，并没有实现体
class IShape(object):
def Area(self):
pass
#定义4个图形类，都是实现Ishape接口，并且每一个图形都有一个可以计算面积的方法，相当于重写接口方法
class Circle(IShape):
def Area(self,radius):
return math.pow(radius,2)*math.pi
class Rectangle(IShape):
def Area(self,longth,width):
return 2*longth*width
class Triangle(IShape):
def Area(self,baselong,height):
return baselong*height/2
class Ellipse(IShape):
def Area(self,long_a,short_b):
return long_a*short_b*math.pi
2、第二步，再定义颜色类这个系列
#定义一个“颜色”的接口，里面定义一个颜色名称的接口方法，只有方法的定义，并没有实现体
class IColor(object):
def color(self):
pass
#定义3个颜色类，都是实现IColor接口，并且每一个图形都有一个可以获取颜色名称的方法，相当于重写接口方法
class Red(IColor):
def color(self,name):
print(f'我的颜色是：{name}')
class Blue(IColor):
def color(self,name):
print(f'我的颜色是：{name}')
class Black(IColor):
def color(self,name):
print(f'我的颜色是：{name}')
3、第三步，定义抽象工厂以及与每一个系列对应的工厂
class IFactory: #模拟接口
def create_shape(self): #定义接口的方法，只提供方法的声明，不提供方法的具体实现
pass
def create_color(self):
pass
#创建形状这一个系列的工厂
class ShapeFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承
def create_shape(self, name): #重写接口中的方法
if name =='Circle':
return Circle()
elif name == 'Rectangle':
return Rectangle()
elif name == 'Triangle':
return Triangle()
elif name == 'Ellipse':
return Ellipse()
else:
return None
#创建颜色这一个系列的工厂
class ColorFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承
def create_color(self, name): #重写接口中的方法
if name =='Red':
return Red()
elif name =='Blue':
return Blue()
elif name =='Black':
return Black()
else:
return None
注意：这里的抽象工厂和“工厂方法模式里面的抽象工厂有点区别，因为这里有两个系列的类型需要产生，所以，抽象工厂里面需要有两个函数接口，一个产生”形状“，一个产生”颜色“，然后再在实现该接口的工厂中分别进行重写。
4、第四步，定义产生工厂类的类——抽象工厂模式的核心所在
定义一个专门产生工厂的类
class FactoryProducer:
def get_factory(self,name):
if name=='Shape':
return ShapeFactory()
elif name=='Color':
return ColorFactory()
else:
return None
注意：这一步是抽象工厂模式最为与众不同的，如果按照 “简单工厂模式 ”，只需要进行到第三步即可，因为然后我分别使用 ShapeFactory工厂类和ColorFactory类去分别产生每一个系列的类的实例即可，但是我们没有这么做。而是再定义一个新的
“ 工厂产生类 ”去让我们决定到底是要产生哪个类的实例。
总结：
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。（这里的FactoryProducer就是超级工厂）
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
