核心思想

装饰者模式（Decorator Pattern）是一种结构型设计模式，通过"包装"现有对象来为其添加额外的功能，而无需改变原有对象的代码。装饰者模式通过创建一个装饰类来扩展对象的功能而不是继承。这样可以灵活地在运行时动态地组合功能。

编辑

结构

1. Component（抽象构件）

定义一个抽象接口以规范准备接受附加责任的对象。

2. ConcretComponent（具体构件）

实现 Component，定义了要被装饰的具体对象。

3. Decorator（抽象装饰者）

实现了 Component 接口，并持有一个 Component 的引用，代表被装饰对象。装饰者类可以在调用原方法的基础上添加额外的功能。

4. ConcreteDecorator（具体装饰者）

实现抽象装饰者的相关方法，并给具体构件对象添加附加的责任。

5. 为什么要先继承再组合：

继承用于"类型化" ：

继承使得装饰器类能够实现与被装饰类相同的接口（或者父类），这确保了装饰器能够在原有的接口上添加功能时，依然能保持原有对象的一致性和可替换性。
通过继承，装饰器可以被用作原类的替代品，不会影响客户端代码对对象的使用和期望。

组合用于"功能增强" ：

组合使得装饰器对象可以持有原始对象，并通过委托的方式来增强其行为。通过组合，装饰器可以在不修改原始类的情况下，动态地为其增加额外的功能或行为。
这种方式比继承更灵活，因为你可以在运行时选择不同的装饰器进行组合，动态增强对象的功能，而不需要提前在类的设计中固定哪些功能是装饰类的一部分。

编辑

现实世界类比

编辑

穿衣服是使用装饰的一个例子。觉得冷时，你可以穿一件毛衣。如果穿毛衣还觉得冷，你可以再套上一件夹克。如果遇到下雨，你还可以再穿一件雨衣。所有这些衣物都 "扩展" 了你的基本行为，但它们并不是你的一部分，如果你不再需要某件衣物，可以方便地随时脱掉。

适用场景

如果你希望在无需修改代码的情况下即可使用对象，且希望在运行时为对象新增额外的行为，可以使用装饰模式。

1. 装饰能将业务逻辑组织为层次结构，你可为各层创建一个装饰，在运行时将各种不同逻辑组合成对象。由于这些对象都遵循通用接口，客户端代码能以相同的方式使用这些对象。

如果用继承来扩展对象行为的方案难以实现或者根本不可行，你可以使用该模式。

1. 许多编程语言使用 final最终关键字来限制对某个类的进一步扩展。复用最终类已有行为的唯一方法是使用装饰模式：用封装器对其进行封装。

优缺点

优点：

灵活性：可以通过组合多个装饰器动态地增强对象的功能，避免了继承层次的问题。
避免子类爆炸：避免了大量的子类继承，尤其是当有多种功能组合时。
符合开闭原则：通过装饰器来扩展功能，不需要修改原有代码。

缺点：

增加复杂性：当多个装饰者一起使用时，代码结构可能会变得复杂。
不容易理解：对于不熟悉设计模式的人，装饰者模式让代码更难理解。

实现步骤

确保业务逻辑可用一个基本组件及多个额外可选层次表示。
找出基本组件和可选层次的通用方法。创建一个组件接口并在其中声明这些方法。
创建一个具体组件类，并定义其基础行为。
创建装饰基类，使用一个成员变量存储指向被封装对象的引用。该成员变量必须被声明为组件接口类型，从而能在运行时连接具体组件和装饰。装饰基类必须将所有工作委派给被封装的对象。
确保所有类实现组件接口。
将装饰基类扩展为具体装饰。具体装饰必须在调用父类方法（总是委派给被封装对象）之前或之后执行自身的行为。
客户端代码负责创建装饰并将其组合成客户端所需的形式。

示例

编辑

// 抽象构建者
public abstract class FastFood {

    private float price;
    private String desc;

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public FastFood() {}

    public abstract float cost();
}

// 具体构建者
public class FriedRice extends FastFood{

    public FriedRice() {
        super(10, "fried rice");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}

// 具体构建者
public class FriedNoodles extends FastFood{

    public FriedNoodles() {
        super(12, "fried noodles");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}

// 抽象装饰者
public abstract class Garnish extends FastFood{

    // 持有一个快餐的引用
    private FastFood fastFood;

    public Garnish(FastFood fastFood, float price, String desc) {
        super(price, desc);
        this.fastFood = fastFood;
    }

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }
}

// 具体装饰者
public class Egg extends Garnish{

    public Egg(FastFood fastFood) {
        super(fastFood, 1, "egg");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + " " + getFastFood().getDesc();
    }
}

// 具体装饰者
public class Bacon extends Garnish{

    public Bacon(FastFood fastFood) {
        super(fastFood, 2, "bacon");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + " " + getFastFood().getDesc();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {

        // 点一份炒饭
        FastFood friedRice = new FriedRice();
        System.out.println(friedRice.getDesc() + ":" + friedRice.cost());

        System.out.println("-----------------------------------------");

        // 加一个鸡蛋
        friedRice = new Egg(friedRice);
        System.out.println(friedRice.getDesc() + ":" + friedRice.cost());

        // 加一个培根
        friedRice = new Bacon(friedRice);
        System.out.println(friedRice.getDesc() + ":" + friedRice.cost());

        System.out.println("-----------------------------------------");

        // 再加一个鸡蛋
        friedRice = new Egg(friedRice);
        System.out.println(friedRice.getDesc() + ":" + friedRice.cost());
    }
}

在源码中的应用

编辑

与其他模式的关系

适配器模式可以对已有对象的接口进行修改，装饰模式则能在不改变对象接口的前提下强化对象功能。此外，装饰还支持递归组合，适配器则无法实现。
适配器能为被封装对象提供不同的接口，代理模式能为对象提供相同的接口，装饰则能为对象提供加强的接口。
责任链模式和装饰模式的类结构非常相似。两者都依赖递归组合将需要执行的操作传递给一系列对象。但是，两者有几点重要的不同之处。
责任链的管理者可以相互独立地执行一切操作，还可以随时停止传递请求。另一方面，各种装饰可以在遵循基本接口的情况下扩展对象的行为。此外，装饰无法中断请求的传递。
组合模式和装饰的结构图很相似，因为两者都依赖递归组合来组织无限数量的对象。
装饰类似于组合，但其只有一个子组件。此外还有一个明显不同：装饰为被封装对象添加了额外的职责，组合仅对其子节点的结果进行了 "求和"。但是，模式也可以相互合作：你可以使用装饰来扩展组合树中特定对象的行为。
大量使用组合和装饰的设计通常可从对于原型模式的使用中获益。你可以通过该模式来复制复杂结构，而非从零开始重新构造。
装饰可让你更改对象的外表，策略模式则让你能够改变其本质。
装饰和代理有着相似的结构，但是其意图却非常不同。这两个模式的构建都基于组合原则，也就是说一个对象应该将部分工作委派给另一个对象。两者之间的不同之处在于代理通常自行管理其服务对象的生命周期，而装饰的生成则总是由客户端进行控制。

「全网最细 + 实战源码案例」设计模式——装饰者模式

核心思想

结构

1. Component（抽象构件）

2. ConcretComponent（具体构件）

3. Decorator（抽象装饰者）

4. ConcreteDecorator（具体装饰者）

5. 为什么要先继承再组合：

现实世界类比

适用场景

优缺点

优点：

缺点：

实现步骤

示例

在源码中的应用

与其他模式的关系