Python设计模式-建造者模式

Python设计模式-建造者模式

代码基于3.5.2，代码如下;

#coding:utf-8
#建造者模式
class Burger():
    name = ""
    price = 0.0
    def getPrice(self):
        return self.price
    def setPrice(self,price):
        self.price = price
    def getName(self):
        return self.name

class cheeseBurger(Burger):
    def __init__(self):
        self.name = "cheese burger"
        self.price = 10.0

class spicyChickenBurger(Burger):
    def __init__(self):
        self.name = "spicy chicken burger"
        self.price = 15.0

class Snack():
    name = ""
    price = 0.0
    type = "SNACK"
    def getPrice(self):
        return self.price
    def setPrice(self,price):
        self.price = price
    def getName(self):
        return self.name

class chips(Snack):
    def __init__(self):
        self.name = "chips"
        self.price = 6.0

class chickenWings(Snack):
    def __init__(self):
        self.name = "chicken wings"
        self.price = 12.0


class Beverage():
    name = ""
    price = 0.0
    type = "BEVERAGE"

    def getPrice(self):
        return self.price

    def setPrice(self, price):
        self.price = price

    def getName(self):
        return self.name


class coke(Beverage):
    def __init__(self):
        self.name = "coke"
        self.price = 4.0


class milk(Beverage):
    def __init__(self):
        self.name = "milk"
        self.price = 5.0

class order():
    burger = ""
    snack = ""
    beverage = ""
    def __init__(self,orderBuilder):
        self.burger = orderBuilder.bBurger
        self.snack = orderBuilder.bSnack
        self.beverage = orderBuilder.bBeverage
    def show(self):
        print("Burger:%s"%self.burger.getName())
        print("Snack:%s"%self.snack.getName())
        print("Beverage:%s"%self.beverage.getName())

class orderBuilder():
    bBurger = ""
    bSnack = ""
    bBeverage = ""
    def addBurger(self,xBurger):
        self.bBurger = xBurger

    def addSnack(self, xSnack):
        self.bSnack = xSnack

    def addBeverage(self, xBeverage):
        self.bBeverage = xBeverage

    def build(self):
        return order(self)

if __name__ == "__main__":
    order_builder = orderBuilder()
    order_builder.addBurger(spicyChickenBurger())
    order_builder.addSnack(chips())
    order_builder.addBeverage(milk())
    order_builder.build().show()

建造者模式分析与解读

建造者模式

建造者模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，作用是将"构建"和"表示"分离，以达到解耦的作用。

代码解读

该例子基于的需求:客户点餐系统。
1、先定义了Burger类，所有的主餐都是由该类继承而来(cheeseBurger,spicyChickenBurger)，定义了Snack类，所有的小吃类都是由该类继承而来(chips,chickenWings)，定义了Beverage类，所有的饮料都是由该类继承而来(coke,milk)；
2、定义了order类，该类主要生成订单；
3、定义了orderBuilder订单建造者类，分别实现了添加主食addBurger、添加小吃addSnack和添加饮料addBeverage方法，当添加完成后调用build方法来生成订单，从而达到建造订单的目的。

代码运行结果如下:

Burger:spicy chicken burger
Snack:chips
Beverage:milk

建造者模式应用场景:

1、目标对象由组件构成的场景中，适合建造者模式；
2、在具体场景中，对象内部接口需要根据不同的参数而调用顺序有所不同时，可以使用建造者模式。

优缺点分析

优点

1、封装性好，用户可以不知道对象的内部构造和细节，就可以直接建造对象；
2、系统扩展容易；
3、建造者模式易于使用，非常灵活，在构造性的场景中很容易实现"流水线"；
4、便于控制细节。

缺点

1、封装的过程对用户不透明。

备注

#建造者模式的通用代码
class product():
    def __init__(self):
        self.partsList = []
    def add(self,part):
        self.partsList.append(part)
    def show(self):
        for part in self.partsList:
            print(part)

class builder():
    def buildPartA(self):
        raise NotImplementedError
    def buildPartB(self):
        raise NotImplementedError
    def getResult(self):
        raise NotImplementedError

class ConcreteBuilder1(builder):
    def __init__(self):
        self.product = product()
    def buildPartA(self):
        self.product.add("1 A")
    def buildPartB(self):
        self.product.add("1 B")
    def getResult(self):
        self.product.show()

class ConcreteBuilder2(builder):
    def __init__(self):
        self.product = product()
    def buildPartA(self):
        self.product.add("2 A")
    def buildPartB(self):
        self.product.add("2 B")
    def getResult(self):
        self.product.show()

class director():
    def construct(self,builder):
        builder.buildPartA()
        builder.buildPartB()
if __name__ == "__main__":
    de = director()
    b1 = ConcreteBuilder1()
    b2 = ConcreteBuilder2()

    de.construct(b1)
    b1.getResult()
    de.construct(b2)
    b2.getResult()