【Python3_进阶系列_004】Python3-工厂设计模式

一、工厂设计模式

设计模式是编程语言中非常重要的优秀代码，常见的设计模式，这里列举三种：工厂模式，单例模式，代理模式。现在介绍常见的常见的工厂设计模式的实现和优化。

工厂设计模式可以有很多种实现方式：简单工厂，工厂方法，抽象工厂。下面依次实现这3种方法，并且抽象工厂是必须要掌握的内容。

二、简单工厂

实例：定义一个水果类，根据水果的名称生成对应的水果实例（Apple,Orange,Banana）

#首先定义Fruit基类：
class Fruit():
    def __init__(self,name):
        self.name = name

    def names(self):
        print('水果是{0}'.format(self.name))

继承基类，定义子类：Apple,Orange,Banana

class Apple(Fruit):
    def names(self):
        super().names()

class Orange(Fruit):
    def names(self):
        super().names()

class Banana(Fruit):
    def names(self):
        super().names()

定义一个过程，根据水果名生成对应的实例：

class Fruit():
    def __init__(self,name):
        self.name = name

    def names(self):
        print('水果是{0}'.format(self.name))

class Apple(Fruit):
    def names(self):
        super().names()

class Orange(Fruit):
    def names(self):
        super().names()

class Banana(Fruit):
    def names(self):
        super().names()

class SimpleFactory(): ##简单工厂类
    def generateFruit(self):
        fruitname = input("请输入水果的名称：")
        if fruitname=='apple':
            Apple(fruitname).names()
        elif fruitname=='banana':
            Banana(fruitname).names()
        else:
            Orange(fruitname).names()

fruit = SimpleFactory()
fruit.generateFruit()

执行过程：

请输入水果的名称：banana
水果是banana

请输入水果的名称：apple
水果是apple

请输入水果的名称：qita
水果是qita

 

总结：简单理解，简单工厂实际就是根据输入对已经存在的类的实例化过程。预先定义了具体的类，根据需要实例化具体的类型对象。

优点：简单工厂也是工厂模式，具有工厂模式的通用优点，无需关系实例化的细节。

缺点：需要预先设置具体的类，如果类很多的情况下，代码大量重复。

三、工厂方法

工厂方法是对每一个类，再定义一个工厂方法，实际使用的时候直接调用对应的工程方法就可以产生对应的实例，无需判断。

实例：定义基类（Furit）和水果类（Apple,Orange,Banana）--这一步骤和简单工厂完全一致

class Fruit():
    def __init__(self,name):
        self.name = name

    def names(self):
        print("水果是{0}".format(self.name))

class Apple(Fruit):
    def __init__(self,name):
        self.name = name
    def names(self):
        print("水果是{0}".format(self.name))

class Orange(Fruit):
    def __init__(self,name):
        self.name = name

    def names(self):
        print("水果是{0}".format(self.name))

class Banana(Fruit):
    def __init__(self,name):
        self.name = name
    def names(self):
        print("水果是{0}".format(self.name))

为每一个类定义一个工厂类，方法返回具体的类

class AppleFactory():
    def names(self):
        return Apple("Apple").names()

class OrangeFactory():
    def names(self):
        return Orange("Orange").names()

class BananaFactory():
    def names(self):
        return Banana("Banana").names()

根据需要直接生产对应的实例，无需判断

apple = AppleFactory()
apple.names()

banana = BananaFactory()
banana.names()

orange = OrangeFactory()
orange.names()

完整的代码：

class Fruit(): ##定义基类
    def __init__(self,name):
        self.name = name

    def names(self):
        print("水果是{0}".format(self.name))

class Apple(Fruit): ##定义具体的实现类
    def __init__(self,name):
        self.name = name
    def names(self):
        print("水果是{0}".format(self.name))

class Orange(Fruit):##定义具体的实现类
    def __init__(self,name):
        self.name = name

    def names(self):
        print("水果是{0}".format(self.name))

class Banana(Fruit):##定义具体的实现类
    def __init__(self,name):
        self.name = name
    def names(self):
        print("水果是{0}".format(self.name))
class AppleFactory(): ##定义工厂类
    def names(self):
        return Apple("Apple").names()

class OrangeFactory():##定义工厂类
    def names(self):
        return Orange("Orange").names()

class BananaFactory(): ##定义工厂类
    def names(self):
        return Banana("Banana").names()


apple = AppleFactory()  ##根据需要直接生产对应的工厂类
apple.names()

banana = BananaFactory()
banana.names()

orange = OrangeFactory()
orange.names()

总结：相比简单工厂，工厂方法模式不仅预先定义了具体的类，并且为每一个类定义了具体的工厂类（实现了类方法），然后根据需要，通过具体的工厂类就可以实现对应的对象。

优点：多封装了一层工厂类，可以根据需要快速生成对应实例

缺点：和简单工厂方法一样，代码会有大量的重复，因为不仅要定义实现类并且要定义工厂。

三、抽象工厂（必须掌握）

前面的简单工厂，工厂方法都有其缺点，代码的重复性很高。抽象方法就是对前面代码的优化。

抽象工厂的继承关系必须先弄清楚之后在写代码：继承关系如下

class AbstractFactory(object):

    def getShape(self):
        return Shape()

    def getColor(self):
        return Color()

class Shape(AbstractFactory):
    def shapeFacory(self,shape):
        if shape =='circle':
            return Circle()
        elif shape=='line':
            return Line()
class Circle(Shape):
    def draw(self):
        print("Draw Circle")

class Line(Shape):
    def draw(self):
        print("Draw Line")

class Color(AbstractFactory):
    def colorFacory(self,color):
        if color =='red':
            return Red()
        elif color=='yellow':
            return Yellow()
class Red(Color):
    def yanse(self):
        print("color is red")

class Yellow(Color):
    def yanse(self):

        print("color is yellow")

yellow = AbstractFactory().getColor().colorFacory("yellow").yanse()
line=AbstractFactory().getShape().shapeFacory('line').draw()

输出：

　　color is yellow
　　Draw Line