装饰器模式：动态地添加功能

欢迎来到设计模式系列的第十篇文章！在之前的文章中，我们已经学习了许多常用的设计模式，今天我们将继续探讨另一个非常有用的设计模式——装饰器模式。

装饰器模式简介

装饰器模式是一种结构型设计模式，它允许你在不改变现有对象结构的情况下，动态地向对象添加功能。

装饰器模式通过创建一个装饰器类，该类包装了原始对象，并在不影响原始对象的情况下，为其添加新的功能。

为什么需要装饰器模式？

在实际应用中，我们经常遇到需要动态地向对象添加功能的情况。如果直接修改对象的代码，可能会导致代码的膨胀和不稳定。而装饰器模式允许我们以灵活的方式添加功能，同时保持代码的稳定性和可维护性。

装饰器模式的实现

为了更好地理解装饰器模式，让我们通过一个例子来演示其实际应用。假设我们正在开发一个咖啡店系统，系统需要提供不同种类的咖啡。我们可以使用装饰器模式来动态地为咖啡添加不同的配料。

首先，我们定义一个抽象类 Coffee，表示咖啡：

public abstract class Coffee {
    public abstract double cost();
    public abstract String getDescription();
}

1
2
3
4
5

然后，我们创建具体的咖啡类，如 Espresso 和 Latte：

public class Espresso extends Coffee {
    @Override
    public double cost() {
        return 2.0;
    }

    @Override
    public String getDescription() {
        return "Espresso";
    }
}

public class Latte extends Coffee {
    @Override
    public double cost() {
        return 2.5;
    }

    @Override
    public String getDescription() {
        return "Latte";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

接下来，我们定义一个抽象装饰器类 CoffeeDecorator：

public abstract class CoffeeDecorator extends Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
}

1
2
3
4
5
6
7
8

然后，我们创建具体的装饰器类，如 MilkDecorator 和 SugarDecorator：

public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double cost() {
        return coffee.cost() + 1.0;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }
}

public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double cost() {
        return coffee.cost() + 0.5;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Sugar";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在客户端代码中，我们可以使用装饰器模式来创建不同的咖啡对象，并动态地添加配料：

public class CoffeeShop {
    public static void main(String[] args) {
        Coffee espresso = new Espresso();
        System.out.println("Cost: " + espresso.cost() + ", Description: " + espresso.getDescription());

        Coffee latteWithMilk = new MilkDecorator(new Latte());
        System.out.println("Cost: " + latteWithMilk.cost() + ", Description: " + latteWithMilk.getDescription());

        Coffee latteWithMilkAndSugar = new SugarDecorator(new MilkDecorator(new Latte()));
        System.out.println("Cost: " + latteWithMilkAndSugar.cost() + ", Description: " + latteWithMilkAndSugar.getDescription());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

通过以上代码，我们可以看到装饰器模式的强大之处。我们可以在不改变咖啡类的情况下，动态地添加不同的配料，从而创建出多种不同的咖啡。

总结

在这篇文章中，我们学习了装饰器模式，它是一种动态地为对象添加功能的设计模式。我们了解了装饰器模式的优点以及为什么在实际应用中需要使用它。通过一个咖啡店系统的例子，我们展示了如何使用装饰器模式来动态地为咖啡添加配料，从而创建出多种不同的咖啡类型。

装饰器模式在实际开发中具有广泛的应用，它可以帮助我们避免修改现有代码的情况下，为对象添加新的功能。通过合理地使用装饰器模式，我们可以编写出灵活、可扩展且易于维护的代码。

其实jdk中的IO框架就广泛在使用的装饰器模式，在不增加类的数量的前提下，通过"组合"两个类，达到增强类功能的效果，这个看起来和"代理"模式十分相似，但是两者在作用和用意上是完全不同的，等后面我们介绍了代理模式后，你可以对比着学习下。