设计模式之工厂类模式【非原创】

工厂模式属于创建型设计模式，需要生成的对象叫做产品，生成对象的地方叫做工厂。

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。
---

一、简单工厂

1.简介

简单工厂模式是指专门定义一个工厂类来负责创建产品类的实例，被创建的产品通常有共同的父类。工厂类中，根据条件决定有那个具体产品类来实现。

２．角色划分

简单工厂一共有三种角色分别是简单工厂角色，抽象产品角色，具体产品角色。

简单工厂角色：

这是工厂模式的核心，负责生产具体的产品。
工厂类可以被外部用户也就是客户端调用，创建产品对象，从而实现外部对象和产品对象的解耦合。

抽象产品角色：

抽象工厂模式所创建的具体产品对象的父类，负责描述所有产品对象共有的特征

具体产品角色：

是指具体的产品，客户端调用工厂的目的就是获取产品对象，在工厂模式中，通常拥有多个具体产品。一般来讲，是抽象产品类的子类，实现了抽象产品类中定义的所有接口方法。

３．简单工厂类图

4.简单工厂示例程序

class Fruit(object):  # 抽象产品角色
""" 水果基类"""
    def produce(self):
        print("Fruit is prodeced")

class Apple(Fruit):  #具体产品角色
""" 水果苹果   """
    def produce(self):
        print("Apple is produced!")

class Banana(Fruit):  # 具体产品角色
"""水果香蕉"""
    def produce(self):
        print("Banana is produced")

class FruitFactory: # 简单工厂角色
    """水果工厂"""
    def fruit_produce(self, name):
        if name == "Bnanan":
            return Banana()
        else:
            return Fruit()

if __name__ == '__main__':
    factory = FruitFactory()
    # 生产一个苹果
    apple = factory.fruit_produce("Apple")
    apple.produce()
    # 生产一个香蕉
    banana = factory.fruit_produce("Banana")
    banana.produce()

5. 优缺点

简单工厂的优点

客户端与工厂进行交互，客户端不在负责生产具体的产品对象，实现了解耦合

简单工厂的缺点

工厂类负责全部的产品的创建，当具体的产品类特别多的时候，我们需要修改工厂的代码，从而加大了维护的难度。

二、工厂模式

1.简介

工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

2.角色划分

工厂模式一共有抽象工厂角色，具体工厂角色，抽象产品角色和具体产品角色四个角色。
相比较简单工厂模式，工厂模式多了一个抽象工厂角色。

抽象工厂角色

具体工厂角色必须继承的父类，（Java中也可以通过实现接口来完成）这是工厂模式的核心。

具体工厂角色

负责生产具体的产品。
工厂类可以被外部用户也就是客户端调用，创建产品对象，从而实现外部对象和产品对象的解耦合。

抽象产品角色

抽象工厂模式所创建的具体产品对象的父类，负责描述所有产品对象共有的特征，是具体产品的父类。

具体产品角色

和简单工厂中的具体产品角色一样，是指具体的产品，客户端调用的目的就是获取产品的对象，工厂模式中通常有多个具体产品，一般来讲是抽象产品类的子类，实现了抽象产品类中定义的所有的接口方法。

3.工厂模式类图

4. 具体代码示例


class Fruit(object):
    """ 水果基类 """
    def produce(self):
        print('Fruit is produced')

class Apple(Fruit):
    """ 水果苹果    """
    def produce(self):
        print('Apple is produced')

class Banana(Fruit):
    """水果香蕉"""
    def produce(self):
        print('Banana is produced')

class FruitFactory:
    """ 水果工厂"""
    def fruit_produce(self):
        return Fruit()

class AppleFruitFactory(FruitFactory):
    """苹果工厂"""
    def fruit_produce(self):
        return Apple()
class BananaFruitFactory(FruitFactory):
    """香蕉工厂 """
    def fruit_produce(self):
        return Banana()

if __name__ == '__main__':
 # 生产一个苹果
    apple_factory = AppleFruitFactory()
    apple = apple_factory.fruit_produce()
    apple.produce()
    # 生产一个香蕉
    banana_factory = BananaFruitFactory()
    banana = banana_factory.fruit_produce()
    banana.produce()

5.优缺点

优点

工厂模式不仅仅具有简单工厂的优点，并且通过继承自抽象工厂觉得的多个具体工厂角色来代替简单工厂模式中的简单工厂角色，让工厂角色能够细化，更容易维护
其次，工厂模式使结构变得灵活起来，当有新的产品产生时，只要按照抽象产品角色，抽象工厂角色来生产对应的具体产品和具体的工厂，就可以被客户端使用，而不必去修改任何已有的代码，因此符合开闭原则，让添加具体工厂和具体类变得十分容易，代码也比较容易维护

三、抽象工厂模式

1.简介

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

与工厂模式的对比

工厂模式针对的是一个抽象产品类，可以派生多个产品子类；而抽象工厂模式针对的是多个抽象产品类，可以派生多种产品子类。
抽象工厂模式和工厂模式都有一个抽象工厂类，可以派生出多个具体工厂类，区别是，前者每个具体工厂只能创建一个具体产品类的实例，后者每个具体工厂类可以创建多个具体产品类的实例

2.角色划分

抽象工厂的角色划分与工厂模式相同

3.类图

4.代码示例

    class Fruit(object):
    """ 水果基类 """
    def fruit_produce(self):
        print('Fruit is produced')
    
    class Juice(object):
    """果汁基类"""
    def juice_produce(self):
        print('juice is produced')

class Apple(Fruit):
    """ 水果苹果    """
    def fruit_produce(self):
        print('Apple is produced')

class Banana(Fruit):
    """水果香蕉"""
    def fruit_produce(self):
        print('Banana is produced')

class AppleJuice(Juice):
    '''苹果汁'''
    def produce(self):
        print('apple juice is produced')

class BananaJuice(Juice):
    '''香蕉汁'''
    def produce(self):
        print('banana juice is produced')


class FruitFactory:
    """ 水果工厂"""
    def fruit_produce(self):
        return Fruit()
    
    def juice_produce(self):
        return Juice()

class AppleFruitFactory(FruitFactory):
    """苹果工厂"""
    def fruit_produce(self):
        return Apple()
    
    def juice_produce(self):
        return AppleJuice()

class BananaFruitFactory(FruitFactory):
    """香蕉工厂 """
    def fruit_produce(self):
        return Banana()
    
    def juice_produce(self):
        return BananaJuice()

if __name__ == '__main__':
 # 生产一个苹果
    apple_factory = AppleFruitFactory()
    apple = apple_factory.fruit_produce()
    apple.produce()

    #生产苹果汁
    apple_factory = AppleFruitFactory()
    aj = apple_factory.juice_produce()
    aj.produce()

    # 生产一个香蕉
    banana_factory = BananaFruitFactory()
    banana = banana_factory.fruit_produce()
    banana.produce()

    # 生产香蕉汁
    banan_factory = BananaFruitFactory()
    bj = banana_factory.juice_produce()
    bj.produce()

5.优缺点

工厂方法针对的是一个产品的等级结构，而抽象方法针对的是多个产品的等级结构；

优点

抽象工厂可以使用同一工厂的等级结构来对付相同或者极为类似的产品等级结构

缺点

在增加新的产品族的时候，是支持开闭原则的。而在增加新的产品结构时（增加水果罐头）就不支持开闭原则了