复习一下工厂模式

简单工厂模式

说明：以下例子都是在python3.x中运行的
简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类或者方法负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码逻辑将会非常复杂。
栗1.

class Animal(object):
    def eat(self, food):
        raise NotImplementedError()

class Dog(Animal):
    def eat(self, food):
        print '狗吃', food

class Cat(Animal):
    def eat(self, food):
        print '猫吃', food

def create_animal(name):
    if name == 'dog':
        return Dog()
    elif name == 'cat':
        return Cat()

def client():
    animal = create_animal('dog')
    animal.eat('肉骨头')
    animal = create_animal('cat')
    animal.eat('鱼骨头')

栗2.

# -*- coding:utf-8 -*-


class A:

    def __init__(self):
        self.word = "运行A"

    def run(self):
        print(self.word)


class B:

    def __init__(self):
        self.word = "运行B"

    def run(self):
        print(self.word)


def Interface(classname):
    """
    简单工厂模式接口函数
    :param classname:
    :return:
    """
    run = dict(A=A, B=B)
    return run[classname]()


if __name__ == '__main__':
    test1 = Interface('A')
    test1.run()
    test2 = Interface('B')
    test2.run()

简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类或者方法负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法或者类代码将会非常复杂。

工厂方法模式

此模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作延迟到其工厂子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，使系统的扩展性变得很好，符合面向对象编程的开闭原则。体代码如下：

# -*- coding: utf-8 -*-

from abc import ABC, abstractmethod


# 组件部分
class Section(ABC):
    @abstractmethod
    def describe(self):
        pass


class PersonalSection(Section):
    def describe(self):
        print("PersonalSection")


class AlbumSection(Section):
    def describe(self):
        print("AlbumSection")


class PatentSection(Section):
    def describe(self):
        print("PatentSection")


class PublicationSection(Section):
    def describe(self):
        print("PublicationSection")


# 工厂部分
class Profile(ABC):
    def __init__(self):
        self.sections = []
        self.create_profile()

    @abstractmethod
    def create_profile(self):
        pass

    def show_sections(self):
        for section in self.sections:
            section.describe()

    def add_section(self, section):
        self.sections.append(section)


class LinkedIn(Profile):
    def create_profile(self):
        self.add_section(PersonalSection())
        self.add_section(PatentSection())
        self.add_section(PublicationSection())


class FaceBook(Profile):
    def create_profile(self):
        self.add_section(PersonalSection())
        self.add_section(AlbumSection())


if __name__ == '__main__':
    linkedin = LinkedIn()
    linkedin.show_sections()
    """
    PersonalSection
    PatentSection
    PublicationSection
    """

    facebook = FaceBook()
    facebook.show_sections()
    """
    PersonalSection
    AlbumSection
    """

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

抽象工厂模式

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

此模式是对工厂方法模式的进一步扩展。在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。

栗1.

```python
# -*- coding:utf-8 -*-


class A:

    def __init__(self):
        self.word = "运行A"

    def run(self):
        print(self.word)


class B:

    def __init__(self):
        self.word = "运行B"

    def run(self):
        print(self.word)


class Interface:
    """
    抽象工厂模式接口类
    :param classname:
    :return:
    """
    def __init__(self, classname=None):
        self.test = classname

    def run(self):
        self.test().run()


if __name__ == '__main__':
    test1 = Interface()
    test1.test = A
    test1.run()
    test1.test = B
    test1.run()

栗2.

# -*- coding: utf-8 -*-

from abc import ABC, abstractmethod


class FruitPizza(ABC):
    @abstractmethod
    def prepare(self):
        pass


class MeatPizza(ABC):
    @abstractmethod
    def serve(self):
        pass


class ApplePizza(FruitPizza):
    def prepare(self):
        print("ApplePizza")


class PeachPizza(FruitPizza):
    def prepare(self):
        print("PeachPizza")


class PorkPizza(MeatPizza):
    def serve(self):
        print("PorkPizza")


class BeefPizza(MeatPizza):
    def serve(self):
        print("BeefPizza")


# 抽象工厂
class PizzaFactory(ABC):
    @abstractmethod
    def create_meat_pizza(self):
        pass

    @abstractmethod
    def create_fruit_pizza(self):
        pass


class IndianPizzaFactory(PizzaFactory):
    def create_meat_pizza(self):
        return PorkPizza()

    def create_fruit_pizza(self):
        return ApplePizza()


class USPizzaFactory(PizzaFactory):
    def create_meat_pizza(self):
        return BeefPizza()

    def create_fruit_pizza(self):
        return PeachPizza()


class PizzaStore(object):
    def make_pizza(self):
        for factory in [IndianPizzaFactory(), USPizzaFactory()]:
            meat_pizza = factory.create_meat_pizza()
            fruit_pizza = factory.create_fruit_pizza()
            meat_pizza.serve()
            fruit_pizza.prepare()


if __name__ == '__main__':
    pizza_store = PizzaStore()
    pizza_store.make_pizza()
    """
    PorkPizza
    ApplePizza
    BeefPizza
    PeachPizza
    """

总结

1、简单工厂：可以在运行时根据客户端传入的参数类型来创建相应的实例
2、工厂方法：定义一个接口来创建对象，但是创建对象由子类完成
3、抽象工厂方法：提供一个接口，无需指定具体的类，就能创建一系列相关的对象
参考链接1
参考链接2
参考链接3

扫描二维码关注公众号，回复： 12439622 查看本文章