装饰者模式（结构型模式）

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

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

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

装饰器模式完全遵守开闭原则

3.1 组成结构

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

3.2 场景设计

快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。我们使用装饰者模式实现对快餐的价格计算；UML类图如下

3.3 实现

抽象构建和具体构建

//抽象快餐类
public abstract class FastFood {

    //快餐价格
    private float price;
    //快餐描述
    private String desc;

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    //计算价格的抽象方法，需要每一个具体的产品去实现计算价格的逻辑
    public abstract float cost();
}

//炒面，具体快餐
public class FriedNoodles extends FastFood{

    public FriedNoodles(){
        //调用父类的有参构造初始化参数
        super(18,"炒面");
    }
    @Override
    public float cost() {
        return super.getPrice();
    }
}

//炒饭（具体快餐）
public class FriedRice extends FastFood{

    public FriedRice(){
        //调用父类的有参构造初始化参数
        super(15,"炒饭");
    }
    @Override
    public float cost() {
        return super.getPrice();
    }
}

抽象装饰和具体装饰

//抽象装饰者
public abstract class Garnish extends FastFood{
    //该类继承了FastFood，又聚合了fastFood，继承是为了继续使用cost方法来计算价格，聚合fastfood用来声明在那个基准上进行装饰
    private FastFood fastFood;

    public Garnish(FastFood fastFood){
        this.fastFood = fastFood;
    }
    public Garnish(FastFood fastFood,float price,String desc){
        super(price,desc);
        this.fastFood = fastFood;
    }
}

//鸡蛋(具体装饰者)
public class Egg extends Garnish{

    //声明构造方法，鸡蛋价格和描述
    public Egg(FastFood fastFood){
        super(fastFood,2,"鸡蛋");
    }
    //计算价格
    @Override
    public float cost() {
        //super.getPrice()表示鸡蛋自己的价格 +getFastFood().cost()（快餐原有的价格）
        return super.getPrice()+ getFastFood().cost();
    }
    //描述

    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }
}

//培根（具体装饰者）
public class Bacon extends Garnish{

    //声明构造方法，鸡蛋价格和描述
    public Bacon(FastFood fastFood){
        super(fastFood,5,"培根");
    }

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

    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //炒饭
        FastFood friedRice = new FriedRice();
        System.out.println(friedRice.getDesc()+ ":"+friedRice.cost());

        //炒饭加鸡蛋
        Egg egg = new Egg(friedRice);
        System.out.println(egg.getDesc()+ ":"+egg.cost());
        //加完鸡蛋再加培根
        Bacon bacon = new Bacon(egg);
        System.out.println(bacon.getDesc()+ ":"+bacon.cost());

        //再加一个鸡蛋
        Egg egg1 = new Egg(bacon);
        System.out.println(egg1.getDesc()+ ":"+egg1.cost());
    }
}

3.4 优缺点分析

优点：

• 饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
• 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点

• 这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性。
• 装饰模式会导致设计中出现许多小类，如果过度使用，会使程序变得很复杂

3.5 使用场景

• 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

  不能采用继承的情况主要有两类：

  • 第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；
  • 第二类是因为类定义不能继承（如final类）

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。