工厂模式(facotory)

简单工厂模式

由工厂函数控制具体生产出来的产品

class car:
    # 产品基类
    def drive(self)
class BMW(car):
    # 产品1: BMW
    def __init__(self, carname):
        self._name = carname
    def drive(self):
        print "Drive the BMW as" + self._name

class Benz(car):
    # 产品2: Benz
    def __init__(self, carname):
        self._name = carname
    def drive(self):
        print "Drive the Benz as" + self._name

class driver:
    # 工厂类 控制 产品
    def drivecar(self, name):
        if name=='BMW':
            return BMW(name)
        elif name=="Benz":
            return Benz(name)
        else:
            # 不想写 exception,随意写一个
            return BMW('anyway')

if __name__=='__main__':
    carname=raw_input()
    dier = driver()
    d = dier.drivecar(carname)
    d.drive()

工厂模式

简单工厂模式添加一个新的产品需要修改工厂类,工厂模式则选择将去掉工厂方法的静态属性

 Factory Method
class car:
    # 产品基类
    def drive(self):
        pass

class BMW(car):
    # 产品1:BMW
    def __init__(self,carname):
        self.__name=carname
    def drive(self):
        print "Drive the BMW as "+self.__name

class Benz(car):
    # 产品2:Benz
    def __init__(self,carname):
        self.__name=carname
    def drive(self):
        print "Drive the Benz as "+self.__name

class driver:
    # 工厂基类
    def driverCar(self):
        return car()

class BMWdriver(driver):
    # 工厂类1: BMWdriver
    def driverCar(self):
        return BMW("BMW")

class Benzdriver(driver):
    # 工厂类2: Benzdriver
    def driverCar(self):
        return Benz("Benz")    

if __name__ == "__main__":
    driver=BMWdriver()
    car=driver.driverCar()
    car.drive()
    driver=Benzdriver()
    car=driver.driverCar()
    car.drive()

抽象工厂模式

产品类变得更加复杂,产品有多个基类,这里就需要采用抽象工厂模式,其中系统中有多个产品族

Abstract Factory
class Newcar:
    # 产品族1基类:
    def drive(self):
        pass

class NewBMW(Newcar):
    # 产品族1产品1: NewBMW
    def __init__(self,carname):
        self.__name=carname
    def drive(self):
        print "Drive the New BMW as "+self.__name

class NewBenz(Newcar):
    # 产品族1产品2: NewBenz
    def __init__(self,carname):
        self.__name=carname
    def drive(self):
        print "Drive the New Benz as "+self.__name

class Oldcar:
    # 产品族2基类:
    def drive(self):
        pass

class OldBMW(Oldcar):
    # 产品族2产品2: OldBenz
    def __init__(self,carname):
        self.__name=carname
    def drive(self):
        print "Drive the Old BMW as "+self.__name

class OldBenz(Oldcar):
     # 产品族2产品2: OldBenz
    def __init__(self,carname):
        self.__name=carname
    def drive(self):
        print "Drive the Old Benz as "+self.__name

class driver:
    # 工厂基类
    def driverNewCar(self):
        return Newcar()
    def driverOldCar(self):
        return Oldcar()

class BMWdriver(driver):
    # 工厂类1
    def driverNewCar(self):
        return NewBMW("NewBMW")
    def driverOldCar(self):
        return OldBMW("OldBMW")

class Benzdriver(driver):
    # 工厂类1
    def driverNewCar(self):
        return NewBenz("NewBenz")
    def driverOldCar(self):
        return OldBenz("OldBenz")    

if __name__ == "__main__":
    driver=BMWdriver()
    car=driver.driverNewCar()
    car.drive()
    car=driver.driverOldCar()
    car.drive()
    driver=Benzdriver()
    car=driver.driverNewCar()
    car.drive()
    car=driver.driverOldCar()
    car.drive()

三种工厂模式主要还是在工厂类或工厂基类上作修改,适用与不同场景,抽象工厂函数使用范围更广.

参考文献

1. http://www.cnblogs.com/wly923/archive/2013/05/09/3068313.html
2. python设计模式案例