Menu
CoddyTech
开始学习

装饰器模式

本课属于 Coddy Python 学习旅程的“面向对象编程”单元。第 51 课，共 64 课。

装饰器模式可以在不改变对象结构的情况下，动态地为对象添加新功能。它通过包装对象来扩展对象的行为。

下面是一个简单的咖啡示例：

class Coffee:
    def cost(self):
        return 5
    
    def description(self):
        return "Simple coffee"

创建能为咖啡添加功能的装饰器：

class MilkDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 2
    
    def description(self):
        return self.coffee.description() + " + Milk"

class SugarDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 1
    
    def description(self):
        return self.coffee.description() + " + Sugar"

每个装饰器都会包装另一个对象，并添加自己的功能。

使用装饰器制作定制咖啡：

# 先从基础咖啡开始
my_coffee = Coffee()
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

# 加入牛奶
my_coffee = MilkDecorator(my_coffee)
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

# 加入糖
my_coffee = SugarDecorator(my_coffee)
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

再创建一个带文本格式的示例：

class Text:
    def __init__(self, content):
        self.content = content
    
    def render(self):
        return self.content

class BoldDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<b>{self.text.render()}</b>"

class ItalicDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<i>{self.text.render()}</i>"

# 逐步构建带格式的文本
message = Text("Hello World")
message = BoldDecorator(message)
message = ItalicDecorator(message)

print(message.render())

输出：

Simple coffee: $5
Simple coffee + Milk: $7
Simple coffee + Milk + Sugar: $8
<i><b>Hello World</b></i>

重点：装饰器模式通过包装对象来添加新行为，而不改变原对象。每个装饰器都会保留对被包装对象的引用，并添加自己的功能。这样，你就可以组合多个装饰器，灵活搭配功能，而不必创建许多子类。

challenge icon

挑战

中等

在这个挑战中，你将实现装饰器设计模式，为咖啡店创建一个灵活的咖啡点单系统。装饰器模式可以动态地为单个对象添加行为，而不影响同一个类中其他对象的行为。

你正在为一家咖啡店构建系统，该系统需要：

  • 提供多种饮品（Espresso、Dark Roast、House Blend、Decaf）
  • 允许顾客为饮品添加调味品（Milk、Mocha、Soy、Whipped Cream）
  • 计算添加调味品后的饮品价格
  1. 完成抽象类 Beverage 及其具体实现，并写入 beverage.py
  2. 在 condiment_decorator.py 中实现抽象类 CondimentDecorator 和具体装饰器
  3. 在 driver.py 中实现测试场景，验证你的实现

亲手试试

# 导入所有需要的类
from beverage import Espresso, HouseBlend, DarkRoast, Decaf
from condiment_decorator import Milk, Mocha, Soy, Whip

# 综合测试用例处理
test_case = input()

if test_case == "basic_beverage_test":
    # 测试饮品的基本功能
    espresso = Espresso()
    print(f"Description: {espresso.get_description()}")
    print(f"Cost: ${espresso.cost():.2f}")

elif test_case == "all_beverages_test":
    # 测试所有饮品类型
    beverages = [Espresso(), HouseBlend(), DarkRoast(), Decaf()]
    for beverage in beverages:
        print(f"{beverage.get_description()}: ${beverage.cost():.2f}")

elif test_case == "single_condiment_test":
    # 测试添加一种配料
    espresso = Espresso()
    espresso_with_milk = Milk(espresso)
    print(f"Description: {espresso_with_milk.get_description()}")
    print(f"Cost: ${espresso_with_milk.cost():.2f}")

elif test_case == "multiple_condiments_test":
    # 测试添加多种配料
    house_blend = HouseBlend()
    decorated_coffee = Mocha(Soy(Whip(house_blend)))
    print(f"Description: {decorated_coffee.get_description()}")
    print(f"Cost: ${decorated_coffee.cost():.2f}")

elif test_case == "all_condiments_test":
    # 测试在一种饮品中添加所有配料
    dark_roast = DarkRoast()
    fully_loaded = Milk(Mocha(Soy(Whip(dark_roast))))
    print(f"Description: {fully_loaded.get_description()}")
    print(f"Cost: ${fully_loaded.cost():.2f}")

elif test_case == "cost_calculation_test":
    # 测试不同组合的价格计算
    espresso = Espresso()
    
    # 分别添加一种配料
    with_milk = Milk(espresso)
    with_mocha = Mocha(espresso)
    
    print(f"Espresso: ${espresso.cost():.2f}")
    print(f"Espresso + Milk: ${with_milk.cost():.2f}")
    print(f"Espresso + Mocha: ${with_mocha.cost():.2f}")

elif test_case == "decoration_order_test":
    # 测试配料的添加顺序是否影响最终结果
    decaf = Decaf()
    
    order1 = Milk(Mocha(decaf))
    order2 = Mocha(Milk(decaf))
    
    print(f"Order 1 - {order1.get_description()}: ${order1.cost():.2f}")
    print(f"Order 2 - {order2.get_description()}: ${order2.cost():.2f}")
    print(f"Same cost: {order1.cost() == order2.cost()}")

elif test_case == "complex_order_test":
    # 测试复杂的饮品订单
    orders = [
        Mocha(Whip(Espresso())),
        Soy(Milk(HouseBlend())),
        Whip(Mocha(Soy(DarkRoast()))),
        Milk(Decaf())
    ]
    
    for i, order in enumerate(orders, 1):
        print(f"Order {i}: {order.get_description()}")
        print(f"Cost: ${order.cost():.2f}")
        print("---")

elif test_case == "double_condiment_test":
    # 测试多次添加同一种配料
    espresso = Espresso()
    double_mocha = Mocha(Mocha(espresso))
    print(f"Description: {double_mocha.get_description()}")
    print(f"Cost: ${double_mocha.cost():.2f}")

elif test_case == "beverage_comparison_test":
    # 比较添加相同配料后，不同饮品的价格
    base_beverages = [Espresso(), HouseBlend(), DarkRoast(), Decaf()]
    
    print("All beverages with Milk + Mocha:")
    for beverage in base_beverages:
        decorated = Milk(Mocha(beverage))
        print(f"{decorated.get_description()}: ${decorated.cost():.2f}")

elif test_case == "condiment_cost_test":
    # 测试每种配料的价格
    espresso = Espresso()
    base_cost = espresso.cost()
    
    condiments = [
        ("Milk", Milk(espresso)),
        ("Mocha", Mocha(espresso)),
        ("Soy", Soy(espresso)),
        ("Whip", Whip(espresso))
    ]
    
    for name, decorated in condiments:
        additional_cost = decorated.cost() - base_cost
        print(f"{name} adds: ${additional_cost:.2f}")

elif test_case == "cheapest_most_expensive_test":
    # 找出最便宜和最贵的基础饮品
    beverages = [
        ("Espresso", Espresso()),
        ("House Blend", HouseBlend()),
        ("Dark Roast", DarkRoast()),
        ("Decaf", Decaf())
    ]
    
    beverages.sort(key=lambda x: x[1].cost())
    print(f"Cheapest: {beverages[0][0]} - ${beverages[0][1].cost():.2f}")
    print(f"Most Expensive: {beverages[-1][0]} - ${beverages[-1][1].cost():.2f}")

elif test_case == "nested_decoration_test":
    # 测试多层嵌套的装饰
    beverage = HouseBlend()
    # 添加 5 层装饰
    decorated = Whip(Soy(Mocha(Milk(Whip(beverage)))))
    print(f"Description: {decorated.get_description()}")
    print(f"Cost: ${decorated.cost():.2f}")
    
    # 统计配料数量
    description = decorated.get_description()
    condiment_count = description.count(" + ")
    print(f"Number of condiments: {condiment_count}")

elif test_case == "cost_breakdown_test":
    # 详细的价格明细
    dark_roast = DarkRoast()
    print(f"Base Dark Roast: ${dark_roast.cost():.2f}")
    
    with_soy = Soy(dark_roast)
    print(f"+ Soy: ${with_soy.cost():.2f}")
    
    with_mocha = Mocha(with_soy)
    print(f"+ Mocha: ${with_mocha.cost():.2f}")
    
    with_whip = Whip(with_mocha)
    print(f"+ Whip: ${with_whip.cost():.2f}")
    
    final_cost = with_whip.cost()
    print(f"Final total: ${final_cost:.2f}")

elif test_case == "description_format_test":
    # 测试描述格式是否一致
    espresso = Espresso()
    test_combinations = [
        Milk(espresso),
        Mocha(Milk(espresso)),
        Whip(Mocha(Milk(espresso))),
        Soy(Whip(Mocha(Milk(espresso))))
    ]
    
    for combo in test_combinations:
        description = combo.get_description()
        print(f"Description: '{description}'")
        # 检查描述是否以基础饮品的名称开头
        starts_correctly = description.startswith("Espresso")
        print(f"Starts with base name: {starts_correctly}")
        print("---")
quiz icon自我测试

这节课包含一个小测验。开始学习即可作答，并记录你的进度。

面向对象编程中的所有课

1OOP 基础

OOP 简介外部文件类与对象self 参数方法属性构造方法 (__init__)回顾：简单计算器

4继承

继承基础super() 函数方法重写多重继承方法解析顺序回顾：员工层次结构

7特殊方法

魔术方法简介运算符重载容器魔术方法回顾：自定义列表

10设计模式第 1 部分

设计模式简介单例模式工厂模式观察者模式策略模式

13最终挑战

在线学习平台银行系统游戏角色开发车辆租赁服务

2装饰器

装饰器简介属性装饰器静态方法装饰器类方法装饰器

5多态

重新认识方法重写鸭子类型抽象类和抽象方法接口设计回顾：形状计算器

8高级面向对象编程概念

组合与继承Mixin静态方法与类方法类装饰器上下文管理器

11设计模式第 2 部分

命令模式适配器模式装饰器模式模板方法模式状态模式组合模式

3类属性

实例变量与类变量属性装饰器私有属性回顾：银行账户管理器

6封装

公有、受保护和私有成员访问修饰符信息隐藏高级属性装饰器回顾：学生记录系统

9高级参数

*args 参数**kwarg 参数

12项目：图书管理

项目概览图书和用户类借阅系统搜索功能管理员界面测试与集成

自己练习： Python 在线编译器