设计模式详解：装饰器模式

设计模式详解：装饰器模式

引用

CSDN

1.

https://m.blog.csdn.net/qq_63275583/article/details/145400473

装饰器模式是一种结构型设计模式，通过"包装"现有对象来为其添加额外的功能，而无需改变原有对象的代码。这种模式通过创建一个装饰类来扩展对象的功能，而不是通过继承。

核心思想

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

结构

1. Component（抽象构件）

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

2. ConcretComponent（具体构件）

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

3. Decorator（抽象装饰者）

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

4. ConcreteDecorator（具体装饰者）

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

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

1. 继承用于“类型化”：

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

1. 组合用于“功能增强”：

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

现实世界类比

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

适用场景

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

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

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

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

优缺点

优点：

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

缺点：

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

实现步骤

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

示例

// 抽象构建者
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());
    }
}  

在源码中的应用

与其他模式的关系

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