介绍

装饰模式，也称包装模式，结构型设计模式之一。

定义

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。

使用场景

需要透明且动态地扩展类的功能时。

结构

装饰模式 UML 图

Component : 抽象组件。接口或抽象类，被装饰的原始对象。
ConcreteComponent : 组件具体实现类。
Decorator : 抽象装饰者，内部需要有一个组件对象的引用。
ConcreteDecorator : 具体的装饰者类。

实现

人穿衣服，衣服为装饰。

/**
 * 人的抽象，对应抽象的Component
 */
public abstract class Person {
    public abstract void dressed();
}

/**
 * 人的具体实现类，男孩，对应 ConcreteComponent 角色
 */
public class Boy extends Person {
    @Override
    public void dressed() {
        System.out.println("穿上底裤");
    }
}

/**
 * 装饰抽象类，对应 Decorator 角色
 */
public class PersonCloth extends Person {

    private Person mPerson;

    public PersonCloth(Person person) {
        mPerson = person;
    }

    @Override
    public void dressed() {
        mPerson.dressed();
    }
}

/**
 * 具体装饰实现类，便宜装扮
 */
public class CheapCloth extends PersonCloth {

    public CheapCloth(Person person) {
        super(person);
    }

    public void dressShorts() {
        System.out.println("穿条短裤");
    }

    @Override
    public void dressed() {
        super.dressed();
        dressShorts();
    }
}

/**
 * 具体装饰实现类，豪华装扮
 */
public class ExpensiveCloth extends PersonCloth {

    public ExpensiveCloth(Person person) {
        super(person);
    }

    private void dressShirt() {
        System.out.println("穿件短袖");
    }

    private void dressLeather() {
        System.out.println("穿件皮衣");
    }

    private void dressJean() {
        System.out.println("穿件牛仔裤");
    }

    @Override
    public void dressed() {
        super.dressed();
        dressShirt();
        dressLeather();
        dressJean();
    }
}

public class Client {

    public static void main(String args[]) {
        Person boy = new Boy();

        PersonCloth clothCheap = new CheapCloth(boy);
        clothCheap.dressed();

        PersonCloth clothExpensive = new ExpensiveCloth(boy);
        clothExpensive.dressed();
    }

}