二十三种设计模式之装饰器模式

装饰器模式的定义与特点

装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

装饰器模式的主要优点有：

• 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用
• 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果
• 装饰器模式完全遵守开闭原则

装饰器模式的结构与实现

通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰器模式的目标。下面来分析其基本结构和实现方法。

1. 模式的结构

装饰器模式主要包含以下角色。

1. 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
2. 具体构件（ConcreteComponent）角色：实现抽象构件，通过装饰角色为其添加一些职责。
3. 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
4. 具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

 装饰器模式的结构图如图 1 所示。

 

2. 模式的实现

装饰器模式的实现代码如下：

package decorator;

public class DecoratorPattern {
    public static void main(String[] args) {
        Component p = new ConcreteComponent();
        p.operation();
        System.out.println("---------------------------------");
        Component d = new ConcreteDecorator(p);
        d.operation();
    }
}

//抽象构件角色
interface Component {
    public void operation();
}

//具体构件角色
class ConcreteComponent implements Component {
    public ConcreteComponent() {
        System.out.println("创建具体构件角色");
    }

    public void operation() {
        System.out.println("调用具体构件角色的方法operation()");
    }
}

//抽象装饰角色
class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        component.operation();
    }
}

//具体装饰角色
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    public void operation() {
        super.operation();
        addedFunction();
    }

    public void addedFunction() {
        System.out.println("为具体构件角色增加额外的功能addedFunction()");
    }
}

程序运行结果如下：

创建具体构件角色
调用具体构件角色的方法operation()
---------------------------------
调用具体构件角色的方法operation()
为具体构件角色增加额外的功能addedFunction()

装饰器模式的应用实例

【示例】用装饰器模式模拟咖啡店点咖啡

类图如下：

2. 模式的实现

装饰器模式的实现代码如下：

抽象基类Food.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:35
 * @Version 1.0
 *
 * 食物抽象基类
 */
public abstract class Food {

    private String desc;

    private float price;

    public String getDesc() {
        return desc;
    }

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

    public float getPrice() {
        return price;
    }

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

    public abstract float cost();
}

Coffee.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:36
 * @Version 1.0
 *
 * 咖啡基类
 */
public abstract class Coffee extends Food{

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

Americano.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:38
 * @Version 1.0
 *
 * 美式咖啡
 */
public class Americano extends Coffee{

    public Americano() {
        setDesc("美式咖啡");
        setPrice(4.5f);
    }

}

Cappuccino.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:41
 * @Version 1.0
 *
 * 卡布奇诺
 */
public class Cappuccino extends Coffee{

    public Cappuccino() {
        setDesc("卡布奇诺");
        setPrice(6.5f);
    }

}

Espresso.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:40
 * @Version 1.0
 *
 * 玛奇朵
 */
public class Espresso extends Coffee{

    public Espresso() {
        setDesc("玛奇朵");
        setPrice(3.5f);
    }

}

咖啡装饰器基类Decorator.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:42
 * @Version 1.0
 *
 * 装饰器基类
 */
public class Decorator extends Food{

    // 目标对象
    private Food target;

    public Decorator(Food target) {
        this.target = target;
    }

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

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

 Chocolate.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:48
 * @Version 1.0
 *
 * 巧克力
 */
public class Chocolate extends Decorator{

    public Chocolate(Food target) {
        super(target);
        setDesc("巧克力");
        setPrice(3.5f);
    }

}

Yogurt.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:47
 * @Version 1.0
 *
 * 酸奶
 */
public class Yogurt extends Decorator{

    public Yogurt(Food target) {
        super(target);
        setDesc("酸奶");
        setPrice(1.5f);
    }

}

测试Main.java

package com.lzp.decorator;

/**
 * @Author LZP
 * @Date 2021/6/18 20:50
 * @Version 1.0
 */
public class Main {

    public static void main(String[] args) {
        // 需求：点一份卡布奇诺咖啡，再加一个巧克力和两盒酸奶
        Food order = new Cappuccino();
        System.out.println(order.getDesc() + "单价：" + order.getPrice() + "元");
        order = new Chocolate(order);
        order = new Yogurt(order);
        order = new Yogurt(order);
        System.out.println("点一份卡布奇诺咖啡，再加一个巧克力和两盒酸奶共计：" + order.cost() + "元");
        System.out.println("点一份卡布奇诺咖啡，再加一个巧克力和两盒酸奶的详细订单：" + order.getDesc());
    }

}

程序测试结果如下：

 到此，我们的装饰器模式就讲解完毕了，下次再见啦，小伙伴们！！！