工厂简单模式模拟

代码：

  1. class LatteCoffee(Coffee):
  2.     """拿铁咖啡"""
  4.     def __init__(self, name):
  5.         super().__init__(name)
  8.     def get_taste(self):
  9.         return '拿铁咖啡'
  13. class MochaCoffee(Coffee):
  14.     """摩卡咖啡"""
  15.     def __init__(self, name):
  16.         super().__init__(name)
  19.     def get_taste(self):
  20.         return '摩卡咖啡'
  24. class CoffeeMaker:
  25.     """咖啡机"""
  27.     @staticmethod
  28.     def make_coffee(coffeeBean):
  29.         if coffeeBean == '拿铁咖啡豆':
  30.             coffee = LatteCoffee('拿铁咖啡')
  31.         elif coffeeBean == '摩卡咖啡豆':
  32.             coffee = MochaCoffee('摩卡咖啡')
  33.         else:
  34.             return None
  35.         return coffee
  38. if __name__ == '__main__':
  39.     latte = CoffeeMaker.make_coffee('拿铁咖啡豆')
  40.     print(latte.get_name(), '制作', latte.get_taste())
  41.     mocha = CoffeeMaker.make_coffee('摩卡咖啡豆')
  42.     print(mocha.get_name(), '制作', mocha.get_taste())

什么是简单工厂模式

专门定义一个类来负责创建其他类的实例，根据传入的参数的不同创建不同类的实例，被创建的实例通常具有一个共同的父类，这个模式叫简单工程模式。
简单工厂模式又称静态工厂方法模式。之所以叫“静态”，是因为在很多静态语言中方法通常被定义成一个静态方法，这样可以通过类名来直接调用方法。

工厂模式的设计思想

我们拿咖啡机制作咖啡，加入不同风格的咖啡豆就产生不同口味的咖啡，这一过程就如同一个工厂，我们加入不同的配料，就会产生出不同的产品，这就是程序设计中的工厂模式的概念。
在工厂模式中，用来创建对象的类叫工厂类，被创建的对象的类叫产品类。

工厂模式三姐妹

工厂模式三姐妹：简单工厂模式、工厂方法模式、抽象工厂模式，这三种模式可以理解为同一种编程思想的三个版本，从简单到高级不断升级。

简单工厂模式

定义

定义一个创建对象的接口，通过参数来决定创建那个类的实例。

优缺点

优点

实现简单、结构清晰。
抽象出一个专门的类来负责某个类对象的创建，分割出创建的职责，不能直接创建具体的对象，只需要传入适当的参数即可。
使用者可以不关注具体对象的类名，只需要知道传入什么参数可以创建哪些需要的对象。

缺点

不易拓展、一旦添加新的产品类，就不得修改工厂的创建逻辑。不符合“开放-封闭”原则，如果要增加或者删除一个产品类，就要修改 if else 的判断代码。
当产品类型较多时，工厂的创建逻辑可能过于复杂，if else 判断会变的非常多。一旦出错所有产品的创建失败，不利于系统的维护。

应用场景

产品具有明显的继承关系，且产品的类型不太多。
所有的产品具有相同的方法和类似的属性，使用者不关系具体的类型，只希望传入合适的参数能返回合适的对象。
尽管简单工厂模式不符合“开放-封闭”原则，但因为它简单，所以依然能在很多项目中用

实战应用

代码：

  1. from enum import Enum
  5. class PenType(Enum):
  6.     """画笔类型"""
  7.     PenTypeLine = 1
  8.     PenTypeRect = 2
  9.     PenTypeEllipse = 3
  13. class Pen:
  14.     """画笔"""
  16.     def __init__(self, name):
  17.         self.__name = name
  19.     def get_type(self):
  20.         pass
  22.     def get_name(self):
  23.         return self.__name
  27. class LinePen(Pen):
  29.     def __init__(self, name):
  30.         super().__init__(name)
  33.     def get_type(self):
  34.         return PenType.PenTypeLine
  38. class RectPen(Pen):
  39.     def __init__(self, name):
  40.         super().__init__(name)
  42.     def get_type(self):
  43.         return PenType.PenTypeRect
  47. class EllipsePen(Pen):
  49.     def __init__(self, name):
  50.         super().__init__(name)
  53.     def get_type(self):
  54.         return PenType.PenTypeEllipse
  57. class PenFactory:
  58.     """画笔工厂类"""
  60.     def __init__(self):
  61.         self.__pens = {}
  63.     def get_single_obj(self, pen_type, name):
  64.         """获得一个实例对象"""
  66.     def create_pen(self, pen_type):
  67.         if self.__pens.get(pen_type) is None:
  68.             if pen_type == PenType.PenTypeLine:
  69.                 pen = LinePen('直线画笔')
  71.             elif pen_type == PenType.PenTypeRect:
  72.                 pen = RectPen('距形画笔')
  74.             elif pen_type == PenType.PenTypeEllipse:
  75.                 pen = EllipsePen('椭圆画笔')
  77.             else:
  78.                 pen = Pen('')
  79.             self.__pens[pen_type] = pen
  80.             return pen
  81.         else:
  82.             return self.__pens[pen_type]
  85. if __name__ == '__main__':
  86.     factory = PenFactory()
  87.     line = factory.create_pen(PenType.PenTypeLine)
  88.     print('创建了%s 对象ID：%s 类型:%s' % (line.get_name(), id(line), line.get_type()))
  89.     rect = factory.create_pen(PenType.PenTypeRect)
  90.     print('创建了%s 对象ID：%s 类型:%s' % (rect.get_name(), id(rect), rect.get_type()))
  91.     rect2 = factory.create_pen(PenType.PenTypeRect)
  92.     print('创建了%s 对象ID：%s 类型:%s' % (rect2.get_name(), id(rect2), rect2.get_type()))
  93.     ellipse = factory.create_pen(PenType.PenTypeEllipse)
  94.     print('创建了%s 对象ID：%s 类型:%s' % (ellipse.get_name(), id(ellipse), ellipse.get_type()))