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

    优点：在原对象基础上额外增加功能，而不影响原对象

    实现：咖啡店里售卖咖啡，加糖和加奶都需要额外收费，有的可以选择加糖，有的客人选择加奶，有的客人则选择原味。其实不管是加糖还是加奶，都是在原咖啡地基础上增加额外属性。

    1、抽象产品

    1. /**
    2.  * 抽象产品-咖啡
    3.  */
    4. public abstract class Coffee {
    6.     /**
    7.      * 获取咖啡名称
    8.      */
    9.     public abstract String getName();
    11.     /**
    12.      * 获取咖啡价格
    13.      */
    14.     public abstract Double getPrice();
    15. }

    2、实际产品

    1. /**
    2.  * 实际产品-蓝山咖啡
    3.  */
    4. public class LanShanCoffee extends Coffee{
    5.     /**
    6.      * 获取咖啡名称
    7.      */
    8.     public String getName(){
    9.         return "蓝山咖啡";
    10.     }
    12.     /**
    13.      * 获取咖啡价格
    14.      */
    15.     public Double getPrice(){
    16.         return 8.0;
    17.     }
    18. }
    20. /**
    21.  * 实际产品-猫屎咖啡
    22.  */
    23. public class MaoShiCoffee extends Coffee{
    24.     /**
    25.      * 获取咖啡名称
    26.      */
    27.     public String getName(){
    28.         return "猫屎咖啡";
    29.     }
    31.     /**
    32.      * 获取咖啡价格
    33.      */
    34.     public Double getPrice(){
    35.         return 9.2;
    36.     }
    37. }

    3、抽象装饰器类

    1. /**
    2.  * 装饰器类
    3.  */
    4. public abstract class Decorator extends Coffee{
    5.     Coffee coffee;
    7.     /**
    8.      * 设置装饰类
    9.      */
    10.     public Decorator(Coffee coffee){
    11.         this.coffee = coffee;
    12.     }
    14.     /**
    15.      * 获取咖啡名称
    16.      */
    17.     public abstract String getName();
    19.     /**
    20.      * 获取咖啡价格
    21.      */
    22.     public abstract Double getPrice();
    23. }

    4、装饰器类实现

    1. /**
    2.  * 牛奶-装饰器
    3.  */
    4. public class MilkDecorator extends Decorator{
    6.     public MilkDecorator(Coffee coffee){
    7.         super(coffee);
    8.     }
    9.     /**
    10.      * 获取咖啡名称
    11.      */
    12.     public String getName(){
    13.         return coffee.getName()+",加牛奶";
    14.     }
    16.     /**
    17.      * 获取咖啡价格
    18.      */
    19.     public Double getPrice(){
    20.         return coffee.getPrice()+1.5;
    21.     }
    22. }
    24. /**
    25.  * 糖-装饰器
    26.  */
    27. public class SugarDecorator extends Decorator{
    29.     public SugarDecorator(Coffee coffee){
    30.         super(coffee);
    31.     }
    32.     /**
    33.      * 获取咖啡名称
    34.      */
    35.     public String getName(){
    36.         return coffee.getName()+",加糖";
    37.     }
    39.     /**
    40.      * 获取咖啡价格
    41.      */
    42.     public Double getPrice(){
    43.         return coffee.getPrice()+0.2;
    44.     }
    45. }

    5、测试

    1. /**
    2.  * 测试装饰器模式
    3.  */
    4. public class TestDecorator {
    5.     public static void main(String [] args){
    6.         Coffee coffee = new LanShanCoffee();
    7.         coffee = new MilkDecorator(coffee);
    8.         coffee = new SugarDecorator(coffee);
    10.         System.out.println(coffee.getName());
    11.         System.out.println(coffee.getPrice());
    13.         Coffee coffee1 = new MaoShiCoffee();
    14.         coffee1 = new MilkDecorator(coffee1);
    16.         System.out.println(coffee1.getName());
    17.         System.out.println(coffee1.getPrice());
    18.     }
    19. }

    测试结果：
    image.png