Python设计模式：构建模式

于 2025-04-07 16:58:09 发布
阅读量818 收藏 15
点赞数 20
分类专栏： python基础 文章标签： python 设计模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34941290/article/details/147044739
版权

1. 什么是构建模式

构建模式（Builder Pattern）是一种创建型设计模式，它允许使用多个简单的对象一步步构建一个复杂的对象。构建模式通过将构建过程与表示分离，使得同样的构建过程可以创建不同的表示。换句话说，构建模式提供了一种灵活的方式来创建复杂对象，避免了构造函数参数过多的问题。

  • 工厂模式通过一个工厂类来创建对象，适合于创建多个相似对象，隐藏了对象创建的具体实现。
  • 构建模式通过构建者和指挥者的组合，逐步构建一个复杂对象，适合于需要多个步骤和多个部分的组合。
  • 组合模式则允许将对象组合成树形结构，适合于处理部分和整体的层次关系。

1.1 工厂模式与构建模式的对比

在工厂模式中，我们将创建一个简单的汽车工厂来生成汽车对象。

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def __str__(self):
        return f"{self.make} {self.model}"


class CarFactory:
    @staticmethod
    def create_car(make, model):
        return Car(make, model)


# 客户端代码
if __name__ == "__main__":
    car1 = CarFactory.create_car("Toyota", "Camry")
    car2 = CarFactory.create_car("Honda", "Accord")

    print(car1)  # 输出: Toyota Camry
    print(car2)  # 输出: Honda Accord

在构建模式中，我们将使用构建者模式逐步构建一个复杂的汽车对象。

# 产品类
class Car:
    def __init__(self):
        self.make = None
        self.model = None
        self.year = None
        self.color = None

    def __str__(self):
        return f"{self.year} {self.color} {self.make} {self.model}"


# 构建者接口
class CarBuilder:
    def set_make(self, make):
        pass

    def set_model(self, model):
        pass

    def set_year(self, year):
        pass

    def set_color(self, color):
        pass

    def build(self):
        pass


# 具体构建者
class ConcreteCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def set_make(self, make):
        self.car.make = make

    def set_model(self, model):
        self.car.model = model

    def set_year(self, year):
        self.car.year = year

    def set_color(self, color):
        self.car.color = color

    def build(self):
        return self.car


# 指挥者
class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_car(self, make, model, year, color):
        self.builder.set_make(make)
        self.builder.set_model(model)
        self.builder.set_year(year)
        self.builder.set_color(color)
        return self.builder.build()


# 客户端代码
if __name__ == "__main__":
    builder = ConcreteCarBuilder()
    director = Director(builder)

    # 构建一辆车
    car = director.construct_car("Toyota", "Camry", 2022, "Blue")
    print(car)  # 输出: 2022 Blue Toyota Camry

1.2 组合模式与构建模式的对比

在组合模式中，我们将创建一个文件系统的结构，允许文件和文件夹以树形结构组合。

class Component:
    def operation(self):
        pass


class File(Component):
    def __init__(self, name):
        self.name = name

    def operation(self):
        return f"File: {self.name}"


class Folder(Component):
    def __init__(self, name):
        self.name = name
        self.children = []

    def add(self, component):
        self.children.append(component)

    def remove(self, component):
        self.children.remove(component)

    def operation(self):
        results = [f"Folder: {self.name}"]
        for child in self.children:
            results.append(child.operation())
        return "\n".join(results)


# 客户端代码
if __name__ == "__main__":
    file1 = File("file1.txt")
    file2 = File("file2.txt")
    folder1 = Folder("Folder 1")
    folder1.add(file1)
    folder1.add(file2)

    print(folder1.operation())

在构建模式中，我们将使用构建者模式逐步构建一个复杂的文件对象。

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

    def __str__(self):
        return f"File: {self.name}"


class Folder:
    def __init__(self, name):
        self.name = name
        self.children = []

    def add(self, component):
        self.children.append(component)

    def remove(self, component):
        self.children.remove(component)

    def __str__(self):
        results = [f"Folder: {self.name}"]
        for child in self.children:
            results.append(str(child))
        return "\n".join(results)


class FileBuilder:
    def __init__(self):
        self.folder = None

    def create_folder(self, name):
        self.folder = Folder(name)

    def add_file(self, file_name):
        if self.folder:
            self.folder.add(File(file_name))

    def build(self):
        return self.folder


# 客户端代码
if __name__ == "__main__":
    builder = FileBuilder()
    builder.create_folder("Folder 1")
    builder.add_file("file1.txt")
    builder.add_file("file2.txt")

    folder = builder.build()
    print(folder)  # 输出: Folder: Folder 1\nFile: file1.txt\nFile: file2.txt

2. 构建模式的结构

构建模式通常包含以下几个角色：

  1. 产品（Product）：表示被构建的复杂对象。
  2. 构建者（Builder）：定义了创建产品的抽象接口，包含构建产品的各个部分的方法。
  3. 具体构建者（ConcreteBuilder）：实现了构建者接口，负责构建产品的具体部分。
  4. 指挥者（Director）：负责管理构建过程，使用构建者来构建产品。
# 产品类
class Car:
    def __init__(self):
        self.make = None
        self.model = None
        self.year = None
        self.color = None

    def __str__(self):
        return f"{self.year} {self.color} {self.make} {self.model}"


# 构建者接口
class CarBuilder:
    def set_make(self, make):
        pass

    def set_model(self, model):
        pass

    def set_year(self, year):
        pass

    def set_color(self, color):
        pass

    def build(self):
        pass


# 具体构建者
class ConcreteCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def set_make(self, make):
        self.car.make = make

    def set_model(self, model):
        self.car.model = model

    def set_year(self, year):
        self.car.year = year

    def set_color(self, color):
        self.car.color = color

    def build(self):
        return self.car


# 指挥者
class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_car(self, make, model, year, color):
        self.builder.set_make(make)
        self.builder.set_model(model)
        self.builder.set_year(year)
        self.builder.set_color(color)
        return self.builder.build()


# 客户端代码
if __name__ == "__main__":
    builder = ConcreteCarBuilder()
    director = Director(builder)

    # 构建一辆车
    car = director.construct_car("Toyota", "Camry", 2022, "Blue")
    print(car)  # 输出: 2022 Blue Toyota Camry

  1. 产品类（Car）：表示被构建的复杂对象，包含多个属性（如品牌、型号、年份和颜色），并实现了一个 __str__ 方法用于输出对象的字符串表示。

  2. 构建者接口（CarBuilder）：定义了创建产品的抽象接口，包含设置汽车各个属性的方法。

  3. 具体构建者（ConcreteCarBuilder）：实现了构建者接口，负责实现构建汽车的具体部分。它创建一个 Car 对象并逐步设置其属性，最后返回构建好的 Car 对象。

  4. 指挥者（Director）：负责管理构建过程，使用构建者来构建产品。它接受一个构建者对象，并通过调用构建者的方法来构建一个完整的 Car 对象。

  5. 客户端代码：创建了一个 ConcreteCarBuilder 实例和一个 Director 实例。通过指挥者的 construct_car 方法，逐步构建了一辆汽车，并最终输出了构建好的汽车对象。

3. 示例 1：构建复杂的餐厅订单系统

在日常开发中，构建模式常用于构建复杂对象的场景。一个典型的例子是餐厅订单系统。在这个系统中，顾客可以选择不同的菜品、饮料和配餐，最终生成一个完整的订单。使用构建模式可以有效地管理这个复杂的构建过程。

在这个示例中，我们将创建一个订单对象，顾客可以通过不同的步骤来构建这个订单。我们将定义以下角色：

  1. 产品（Order）：表示顾客的订单，包含多个菜品和饮料。
  2. 构建者（OrderBuilder）：定义了创建订单的抽象接口，包含添加菜品和饮料的方法。
  3. 具体构建者（ConcreteOrderBuilder）：实现了构建者接口，负责构建订单的具体部分。
  4. 指挥者（Director）：负责管理构建过程，使用构建者来构建订单。
# 产品类
class Order:
    def __init__(self):
        self.dishes = []
        self.drinks = []

    def add_dish(self, dish):
        self.dishes.append(dish)

    def add_drink(self, drink):
        self.drinks.append(drink)

    def __str__(self):
        order_details = "Order Details:\n"
        order_details += "Dishes:\n" + "\n".join(self.dishes) + "\n"
        order_details += "Drinks:\n" + "\n".join(self.drinks)
        return order_details


# 构建者接口
class OrderBuilder:
    def add_dish(self, dish):
        pass

    def add_drink(self, drink):
        pass

    def build(self):
        pass


# 具体构建者
class ConcreteOrderBuilder(OrderBuilder):
    def __init__(self):
        self.order = Order()

    def add_dish(self, dish):
        self.order.add_dish(dish)

    def add_drink(self, drink):
        self.order.add_drink(drink)

    def build(self):
        return self.order


# 指挥者
class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_order(self, dishes, drinks):
        for dish in dishes:
            self.builder.add_dish(dish)
        for drink in drinks:
            self.builder.add_drink(drink)
        return self.builder.build()


# 客户端代码
if __name__ == "__main__":
    builder = ConcreteOrderBuilder()
    director = Director(builder)

    # 构建一个订单
    dishes = ["Spaghetti", "Caesar Salad", "Grilled Chicken"]
    drinks = ["Coke", "Water"]
    order = director.construct_order(dishes, drinks)

    print(order)  # 输出订单详情


Order Details:
Dishes:
Spaghetti
Caesar Salad
Grilled Chicken
Drinks:
Coke
Water

  1. 产品类（Order）：表示顾客的订单，包含多个菜品和饮料。它提供了添加菜品和饮料的方法，并实现了一个 __str__ 方法用于输出订单的详细信息。

  2. 构建者接口（OrderBuilder）：定义了创建订单的抽象接口，包含添加菜品和饮料的方法。

  3. 具体构建者（ConcreteOrderBuilder）：实现了构建者接口，负责构建订单的具体部分。它创建一个 Order 对象并逐步添加菜品和饮料，最后返回构建好的订单对象。

  4. 指挥者（Director）：负责管理构建过程，使用构建者来构建订单。它接受一个构建者对象，并通过调用构建者的方法来构建一个完整的订单对象。

  5. 客户端代码：创建了一个 ConcreteOrderBuilder 实例和一个 Director 实例。通过指挥者的 construct_order 方法，逐步构建了一个订单，并最终输出了订单的详细信息。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值