Examples to explain the use of the Decorator pattern in Java design pattern programming

Concept

The decorator pattern dynamically attaches responsibilities to objects. To extend functionality, decorators provide a more flexible alternative to inheritance.

The decorator and the decorated object have the same supertype.
You can wrap an object with one or more decorators.
Since the decorator and the decorated object have the same super type, any occasion where the original object (wrapped) is required, the decorated object can be used instead.
The decorator can add its own behavior before and/or after the behavior of the delegated decorator to achieve a specific purpose.
Objects can be decorated at any time, so you can dynamically and unlimitedly decorate
objects with your favorite decorators at runtime.

In Java, many classes under the io package are the embodiment of the typical decorator pattern, such as:

new BufferedOutputStream(OutputStream out)

new BufferedInputStream(InputStream in );

new PrintWriter(OutputStream out)

new FilterReader(Reader in);

The decorated class implements the same interface as the decorated class,
is decorated Class, it doesn’t matter which implementation class is used to decorate it.
The same business method, the decorated class calls the method of the decorated class to enhance the function of the decorated class

Example:
Class diagram

public interface IReader { 
  void read(); 
} 
 
public class Reader implements IReader { 
  
  @Override
  public void read() { 
    System.out.println("read of Reader"); 
  } 
  
} 
 
public class BufferedReader implements IReader { 
    
  private IReader mReader; 
  public BufferedReader(IReader reader) { 
    this.mReader = reader; 
  } 
    
  @Override
  public void read() { 
    System.out.println("read of BufferedReader"); 
    mReader.read(); 
  } 
  
} 
 
public class Test { 
  public static void main(String[] args) { 
    Reader reader = new Reader(); 
    reader.read(); 
    System.out.println("----------"); 
    BufferedReader bufferedReader = new BufferedReader(reader); 
    bufferedReader.read(); 
  
  } 
}

Features:
1. Decorated objects and real objects have the same interface. This way the client object can interact with the decorated object in the same way as a real object.
2. The decoration object contains a reference to the real object
3. The decoration object accepts all requests from the client. It forwards these requests to the real objects.
4. Decoration objects can add some additional functions before or after forwarding these requests. This ensures that additional functionality can be added externally at runtime without modifying the structure of a given object.
In object-oriented design, functional extension of a given class is usually achieved through inheritance. After decoration, the real object is held to enhance its functionality.

The difference between decorator and adapter patterns:
About new responsibilities: Adapters can also add new responsibilities during conversion, but the main purpose is not here. The decorator pattern mainly adds new responsibilities to the decorator.
About the object it wraps: The adapter knows the details of the person being adapted (that is, the adaptation class). The decorator only knows what its interface is,
As for its specific type (whether it is a base class or other derived class), it is only known during runtime.

For more examples to explain the application of Decorator pattern in Java design pattern programming, please pay attention to the PHP Chinese website for related articles!