Decorator mode:
Dynamically adds some extra properties or behavior to the object. The decorator mode is more flexible than using inheritance.

UML diagram:

In general, the decorator mode has the following participants:

• Component: The parent class of the decorator and the decorator. It is an interface or abstract class that defines the basic behavior.
• ConcreteComponent: defines the specific object, that is, the decorator
• Decorator: An abstract decorator that inherits from Component and extends ConcreteComponent from an outer class. For ConcreteComponent, you don't need to know the existence of the Decorator, which is an interface or abstract class.
• ConcreteDecorator: a concrete decorator used to extend ConcreteComponent

Note: The decorator and the decorator object have the same supertype, because the decorator and the decorator must be of the same type.Inheritance is used here to achieve type matching, rather than using inheritance to get behavior.

Using inheritance design subclasses can only be statically determined at compile time, and all subclasses inherit the same behavior; using a combination of methods to extend an object can be dynamically extended at runtime. Decorator mode follows the open-close principle:Classes should be open to extensions and closed to modifications.With decorators, we can implement new decorators to add new behavior without modifying existing code, and if we rely solely on inheritance, we must modify the existing code whenever new behavior is required.

Example:

Suppose a dessert shop sells cakes. In addition to cakes, you can also arrange fruits, candles, etc. on the cake, but fruits and candles are available at an extra charge.Suppose the price of a cake is 66 yuan, and the fruit and candle need to pay an extra 10 yuan respectively. How do you calculate the price dynamically?The code posted in the example has been uploaded to Github:Decorator mode.
First, define the component class, which is also the superclass of the decorator and the decorator Sweet .java:

public abstract class Sweet {
    String description = "Sweet";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

Define the decorator cake class, Cake .java:

public class Cake extends Sweet {
    @Override
    public String getDescription() {
                 Return "a cake";
    }

    @Override
    public double cost() {
        return 66;
    }
}

Define the abstract decorator class Decorator.java:

public abstract class Decorator extends Sweet {
    public abstract String getDescription();
}

Define the specific decorator fruit class, FruitDecorator.java:

public class FruitDecorator extends Decorator {
    Sweet sweet;

    public FruitDecorator(Sweet sweet) {
        this.sweet = sweet;
    }

    @Override
    public String getDescription() {
                 Return sweet.getDescription() + ",fruit";
    }

    @Override
    public double cost() {
        return sweet.cost() + 10;
    }
}

Define the specific decorator candle class, CandleDecorator.java:

public class CandleDecorator extends Decorator {
    Sweet sweet;

    public CandleDecorator(Sweet sweet) {
        this.sweet = sweet;
    }

    @Override
    public String getDescription() {
                 Return sweet.getDescription() + ", candle";
    }

    @Override
    public double cost() {
        return sweet.cost() + 10;
    }
}

Finally settle the price according to different options:

public static void main(String[] args) {

    Cake cake = new Cake();
         System.out.println(cake.getDescription() + "total cost" + cake.cost());

    FruitDecorator fruitDecorator = new FruitDecorator(cake);
         System.out.println(fruitDecorator.getDescription() + "total cost" + fruitDecorator.cost());

    CandleDecorator candleDecorator = new CandleDecorator(fruitDecorator);
         System.out.println(candleDecorator.getDescription() + "total cost" + candleDecorator.cost());

    }

The full code address has been uploaded to Github:Decorator mode.
Execution result:

a cake, a total cost of 66.0
 A cake, fruit, a total cost of 76.0
 A cake, fruit, a candle, costing a total of 86.0

visible,The decorator pattern can be very flexible and dynamically add new behavior to the decorator. Its shortcomings also show that more objects must be managed, but the decorator pattern can be modeled like a factory pattern or a generator. Use one piece to avoid this problem.

PS: When we use the java.IO class, we are similar to the following:

new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream( "io.txt" )));

The java.IO class also uses the decorator mode! Is it clear a lot?

to sum up:
1. The decorator and the decorator object have the same supertype, so in any occasion where the original object (decorator) is needed, the decorated object can be used instead of the original object.
2, can wrap an object (decorator) with one or more decorators
3、The decorator can add his or her own behavior before or after the entrusted decorator's behavior to achieve a specific purpose.
4, the decorator can be decorated at any time, so you can decorate the object with your favorite decorator dynamically and indefinitely at runtime.
5, the decorator will lead to a lot of small objects, if used excessively, it will make the program complicated.