定义：装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
简单来说：人靠衣装，佛靠金装。
给一个物品装饰后 获得新的功能
先来看模板代码：
抽象的组件

public abstract class Component {

    public abstract void operate();
    
}

具体的组件

public class ConcreteComponent extends Component {

    @Override
    public void operate() {
        // 具体的逻辑
    }

}

抽象的装饰器

public abstract class Decorator extends Component {

    private Component component;

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

    @Override
    public void operate() {
        component.operate();
    }

}

具体的装饰对象：

public class ConcreteDecoratorA extends Decorator {

    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operate() {
        operateA();
        super.operate();
        operateB();
    }

    public void operateA() {
        //
    }

    public void operateB() {
        //
    }
}

案例 人穿衣服:

定义抽象的人：

public abstract class Person {

    /**
     * 抽象穿衣方法
     */
    public abstract void dress();

}

定义一个男孩

public class Boy extends Person {

    @Override
    public void dress() {
        System.out.println("穿了内衣内裤");
    }

}

定义一个抽象的穿衣服类

public abstract class Cloth extends Person {

    protected Person person;

    public Cloth(Person person) {
        this.person = person;
    }

    @Override
    public void dress() {
        person.dress();
    }

}

装饰器 -衣服：

public class ExpensiveCloth extends Cloth {

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

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

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

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

装饰器-裤子：

public class CheapCloth extends Cloth {

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

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

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

}

客户端代码：

public class Client {

    public static void main(String[] args) {
        // 被装饰的对象
        Boy boy = new Boy();

        // 装饰对象
        ExpensiveCloth c1 = new ExpensiveCloth(boy);
        c1.dress();

        // 另外一种装饰
        CheapCloth c2 = new CheapCloth(boy);
        c2.dress();

    }

}

其实 java中的IO就是最典型的装饰器模式了 以上便是装饰器模式的简单应用