设计模式---装饰者模式

定义：动态地给对象添加一些额外的职责或者行为，装饰器模式相比于生成子类更为灵活

使用场景：

1.用于拓展一个类的功能或者给一个类添加附加职责
2.动态的给一个对象添加功能，这些功能可以再动态的撤销。
3.需要为一批的兄弟类进行改装或加装功能。

介绍：

装饰器模式组成：

1. 抽象组件角色(Component): 定义可以动态添加任务的对象的接口
2. 具体组件角色(ConcreteComponent)：定义一个要被装饰器装饰的对象，即 Component 的具体实现

1. 抽象装饰器(Decorator): 维护对组件对象和其子类组件的引用
2. 具体装饰器角色(ConcreteDecorator)：向组件添加新的职责

场景引入：

手抓饼会有很多配菜.怎么点(组装) 是顾客决定的.那么 我们怎么做到灵活的给客户生产手抓饼呢?? 如果我需要一个加2个鸡蛋加1根香肠的煎饼 那么用我们现在的类结构是创建不出来的，也无法自动计算出价格，除非再创建一个类做定制。如果需求再变，一直加定制

抽象类

public  abstract class Battercake {

    public abstract String getMsg();

    public abstract int getPrice();
}

具体组件角色：

//煎饼基础类
public class BaseBattercake extends Battercake {
    @Override
    public String getMsg(){ return "煎饼";}

    @Override
    public int getPrice(){ return 5;}
}

//必买套餐

public class MustBattercake extends Battercake {
    @Override
    public String getMsg() {

        return "煎饼+可乐";
    }

    @Override
    public int getPrice() {
        return 10;
    }
}

抽象装饰器(Decorator)

//创建一个扩展套餐的抽象装饰器
public class BattercakeDecotator extends Battercake {
    //静态代理，委派
    //(指定抽象类 而不指定BaseBattercake 实体是为了灵活,
    //因为可能以后会有多个类似BaseBattercake 继承了Battercake 的实现类)
    private Battercake battercake;

    public BattercakeDecotator(Battercake battercake) {
        this.battercake = battercake;
    }

    @Override
    public String getMsg() {
        return  this.battercake.getMsg();
    }

    @Override
    public int getPrice() {
        return  this.battercake.getPrice();
    }
}

具体的装饰器角色

//鸡蛋类

public class EggDecorator extends BattercakeDecotator {
    public EggDecorator(Battercake battercake) {
        super(battercake);
    }

    @Override
    public String getMsg() {
        return super.getMsg()+ "1个鸡蛋";
    }

    @Override
    public int getPrice() {
        return super.getPrice()+1;
    }
}

//香肠类

public class SausageDecorator extends BattercakeDecotator {
    public SausageDecorator(Battercake battercake) {
        super(battercake);
    }

    @Override
    public String getMsg() {
        return super.getMsg()+ "1根香肠";
    }

    @Override
    public int getPrice() {
        return super.getPrice()+2;
    }
}

测试类

public class Test {
    public static void main(String[] args){
        //Battercake battercake = new BaseBattercake();
        Battercake battercake = new MustBattercake();
        //煎饼有点小，想再加一个鸡蛋
        battercake = new EggDecorator(battercake);
        //再加一个鸡蛋
        battercake = new EggDecorator(battercake);
        //很饿，再加根香肠
        battercake = new SausageDecorator(battercake);
        //加点土豆丝
        battercake = new PotatoDecorate(battercake);

        System.out.println(battercake.getMsg() + ",总价" + battercake.getPrice());
    }

}

优点：

1、装饰器是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象扩展功能，即插即用。

2、通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果。

3、装饰器完全遵守开闭原则。

缺点：

1、会出现更多的代码，更多的类，增加程序复杂性。

2、动态装饰时，多层装饰时会更复杂。追踪代码更难看点

与代理模式的区别

在学习装饰器模式时，会发现它与代理模式无论从实现结构，还是功能目的都非常接近；

装饰器模式侧重的是对功能的增强，不改变原功能；

装饰器模式使用方明确知道自己需要什么的增强功能，硬编码使用；

代理模式侧重于对原功能的改变（特别是访问权限的控制）

在java.io中的应用

 

InputStream使用了装饰者模式，其中InputStream是被装饰者，FilterInputStream是装饰者，而ByteArrayInputStream等就类似固定套餐，DataInputStream等就类似于鸡蛋香肠