装饰者模式

一、装饰者模式的介绍

1、定义

       装饰者模式就是动态地给一个对象添加一些额外的职责。就增加功能来说，装饰者模式比生成子类更为灵活。它允许向一个现有的对象添加新的功能，同时又不改变其结构，这种类型的设计模式属于结构型模式。

       装饰者模式中存在以下几个角色：

• 抽象构件角色（Component）：该角色用于规范需要装饰的对象（原始对象）。
• 具体构建角色（ConcreteComponent）：该角色实现抽象构件接口，定义一个需要装饰的原始类。
• 装饰角色（Decorator）：该角色持有一个构件对象的实例，并定义一个与抽象构建接口一致的接口。
• 具体装饰角色（ConcreteDecorator）：该角色负责对构件对象进行装饰。

       装饰者模式的类图如下：

2、应用场景

• 需要扩展一个类的功能，或者给一个类添加附加功能。
• 需要动态地给一个对象增加功能，这些功能可以动态地撤销。
• 需要为一批类进行改装或增加功能。

3、优缺点

（1）优点

• 装饰类和被装饰类可以独立发展，而不会相互耦合。即Component类无需知道Decorator类，Decorator类是从外部扩展Component类的功能，而Decorator也不用知道具体的构件。
• 装饰模式是继承关系的一个替代方案。装饰类Decorator不管装饰多少层，返回的对象还是Component。
• 装饰模式可以动态地扩展一个实现类的功能。

（2）缺点

• 会增加程序复杂性，会增加更多的类。
• 动态装饰时，操作多层装饰复杂。

二、装饰者模式的实现

       场景描述：根据不同的需求对刚建好的房屋进行装饰，其类图如下：

具体实现代码如下：

首先编写一个抽象的房子类House：

/**
 * 抽象的房子house类
 */
public abstract class House {
    /**
     * 装饰品
     */
    public abstract void possess();
    /**
     * 计算价格
     */
    public abstract  double cost();
    /**
     *  输出总价格
     */
    public void printPrice(){
        System.out.println("耗费的总价格为：" + this.cost());
    }
}

然后再定义两个抽象的房子主体：普通房子和高级房子

public class CommonHouse extends House{
    @Override
    public void possess() {
        System.out.println("斯是陋室，惟吾德馨");
    }

    @Override
    public double cost() {
        return 10000;
    }
}

public class HighHouse extends House{
    @Override
    public void possess() {
        System.out.println("豪华别墅，吾之所爱");
    }

    @Override
    public double cost() {
        return 40000;
    }
}

定义一个抽象的房子装饰类，继承House，并持有House的实例

/**
 * 抽象的房子装饰类
 */
public abstract class HouseDecorator extends House{
    private House house;

    public HouseDecorator(House house) {
        this.house = house;
    }

    @Override
    public void possess() {
        this.house.possess();
    }

    @Override
    public double cost() {
        return this.house.cost();
    }
}

定义具体的装饰类：沙发、桌子、床：

public class DecorationSofa extends HouseDecorator{
    public DecorationSofa(House house) {
        super(house);
    }

    @Override
    public void possess() {
        super.possess();
        setSofa();
    }

    private void setSofa(){
        System.out.println("舒适沙发，让人留恋");
    }

    @Override
    public double cost() {
        return super.cost() + 1567.9;
    }
}

public class DecorationDesk extends HouseDecorator{
    public DecorationDesk(House house) {
        super(house);
    }

    @Override
    public void possess() {
        super.possess();
        setDesk();
    }
    private void setDesk(){
        System.out.println("小木桌，一人学习足矣");
    }

    @Override
    public double cost() {
        return super.cost() + 156.2;
    }
}

public class DecorationBed extends HouseDecorator{
    public DecorationBed(House house) {
        super(house);
    }

    @Override
    public void possess() {
        super.possess();
        setBed();
    }

    private void setBed(){
        System.out.println("温馨小床，甜梦有你");
    }

    @Override
    public double cost() {
        return super.cost() + 525.6;
    }
}

接下来，就使用一下装饰者模式：

public class Client {
    public static void main(String[] args) {
        House commonHouse = new CommonHouse();
        commonHouse = new DecorationBed(commonHouse);
        commonHouse = new DecorationDesk(commonHouse);
        commonHouse.possess();
        commonHouse.printPrice();
        System.out.println("===========");
        House highHouse = new HighHouse();
        highHouse = new DecorationBed(highHouse);
        highHouse = new DecorationSofa(highHouse);
        highHouse.possess();
        highHouse.printPrice();
    }
}

执行结果如下：