1 Definición

El patrón Decorator, también conocido como patrón Wrapper, es una alternativa a la herencia. Se refiere a agregar dinámicamente algunas funciones a un objeto sin cambiar la estructura del objeto.

2 Ventajas y desventajas

2.1 Ventajas

Decorator es un poderoso complemento de la herencia, que es más flexible que la herencia. Sin cambiar el objeto original, puede extender dinámicamente funciones a un objeto, plug and play.
Se pueden lograr diferentes efectos usando clases no decorativas y la permutación y combinación de estas clases decorativas.
El patrón decorador se adhiere completamente al principio abierto-cerrado

2.2 Desventajas

El patrón decorador agregará muchas subclases y el uso excesivo aumentará la complejidad del programa.

3 Estructura e implementación del patrón decorador

El diagrama de clases para el patrón Decorator se ve así:

El patrón decorador incluye principalmente los siguientes roles.

Rol de componente abstracto: defina una interfaz abstracta para estandarizar objetos que están listos para recibir responsabilidades adicionales.
Roles de ConcreteComponent: implemente componentes abstractos y agrégueles algunas responsabilidades decorando roles.
Rol de decorador abstracto: hereda componentes abstractos y contiene instancias de componentes concretos, que pueden extender las funciones de componentes concretos a través de sus subclases.
Función ConcreteDecorator: implementa métodos relacionados con la decoración abstracta y agrega responsabilidades adicionales a los objetos de componentes concretos.

4 Implementación de código

Todos deberían haber visto una caricatura japonesa "Tiejia Xiaobao", el robot número 1 en ella, Kabuda, en tiempos normales, es un robot torpe pero muy lindo, cuando necesitan luchar por la paz Cuando la estrella está en el juego, se transformará en un Kabuda con un poder de combate excepcional y, finalmente, obtendrá su Kabuda Giant, que eleva el poder de combate a un nuevo nivel. En este ejemplo, Kabuda transformado y Kabuda Gigante son decoraciones de Kabuda ordinario, mejorando las habilidades de Kabuda.

4.1 Interfaz KaBuDa KaBuDa

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-09-07 12:01
 **/
public interface KaBuDa {

    /**
     * 示人的形象
     */
    void display();
}

4.2 KaBuDa común

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-09-07 14:49
 **/
public class CommonKaBuDa implements KaBuDa{

    @Override
    public void display() {
        System.out.println("我是普通卡布达，卡布卡布卡布");
    }
}

4.3 Transformación KaBuDa

**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-09-07 15:20
 **/
public class TransfigurationKaBuDa extends Decorator{

    public TransfigurationKaBuDa(KaBuDa kaBuDa) {
        super(kaBuDa);
    }

    @Override
    public void display() {
        super.display();
        System.out.println("启动超级变换形态---超级变换形态");
    }
}

4.4 Gigante KaBuDa

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-09-07 15:49
 **/
public class GiantKaBuDa extends Decorator{

    public GiantKaBuDa(KaBuDa kaBuDa) {
        super(kaBuDa);
    }

    @Override
    public void display() {
        super.display();
        System.out.println("超级卡布达巨人");
    }
}

4.5 Programa principal

/**
 * @program: design-pattern-learning
 *
 * @author: zgr
 * @create: 2021-09-07 11:57
 **/
public class MainClass {
    public static void main(String[] args) {
        System.out.println("-----------------1--------------------");
        KaBuDa commonKaBuDa = new CommonKaBuDa();
        commonKaBuDa.display();
        System.out.println("-----------------2--------------------");
        System.out.println("蜻蜓队长: 比赛开始");
        System.out.println("-----------------3--------------------");
        KaBuDa transfigurationKaBuDa = new TransfigurationKaBuDa(commonKaBuDa);
        transfigurationKaBuDa.display();
        System.out.println("-----------------4--------------------");
        System.out.println("呼唤卡布达巨人");
        System.out.println("-----------------5--------------------");
        KaBuDa giantKaBuDa = new GiantKaBuDa(transfigurationKaBuDa);
        giantKaBuDa.display();
    }
}

4.6 Resultados de ejecución

Como resultado, se vio que Kabuda estaba constantemente decorada y finalmente alcanzó el estado invencible de tener gigantes de Kabuda.

5 Simplificación del patrón decorador

En circunstancias normales, el patrón decorador no tiene una interfaz decorada abstracta, sino solo un objeto decorado específico. Esto es para considerar eliminar Componentla clase (interfaz) y tratarla Decoratorcomo una ConcreteComponentsubclase. Como se muestra abajo: