1 Definição

O padrão Decorator, também conhecido como padrão Wrapper, é uma alternativa à herança. Refere-se a adicionar dinamicamente algumas funções a um objeto sem alterar a estrutura do objeto.

2 Vantagens e desvantagens

2.1 Vantagens

Decorator é um poderoso complemento para herança, que é mais flexível que herança. Sem alterar o objeto original, ele pode estender funções dinamicamente a um objeto, plug and play.
Diferentes efeitos podem ser alcançados usando classes não decorativas e a permutação e combinação dessas classes decorativas
O padrão decorador adere totalmente ao princípio aberto-fechado

2.2 Desvantagens

O padrão decorador adicionará muitas subclasses e o uso excessivo aumentará a complexidade do programa.

3 Estrutura e implementação do padrão decorador

O diagrama de classes para o padrão Decorator é assim:

O padrão decorador inclui principalmente as seguintes funções.

Função do Componente Abstrato: Defina uma interface abstrata para padronizar objetos que estão prontos para receber responsabilidades adicionais.
Funções do ConcreteComponent: Implemente componentes abstratos e adicione algumas responsabilidades a eles decorando funções.
Função de decorador abstrato: herda componentes abstratos e contém instâncias de componentes concretos, que podem estender as funções de componentes concretos por meio de suas subclasses.
Função ConcreteDecorator: implementa métodos relacionados à decoração abstrata e adiciona responsabilidades adicionais a objetos de componentes concretos.

4 Implementação do código

Todo mundo deveria ter visto um desenho japonês "Tiejia Xiaobao", o robô nº 1 nele, Kabuda, em tempos normais, ele é um robô desajeitado, mas muito fofo, quando eles precisam lutar pela paz Quando a estrela está no jogo, ele se transformará em um Kabuda com excelente poder de combate e, finalmente, ele obtém seu Kabuda Giant, que eleva o poder de combate a um novo nível. Neste exemplo, Kabuda transformado e Gigante de Kabuda são decorações de Kabuda comum, aprimorando as habilidades de Kabuda.

4.1 Interface KaBuDa KaBuDa

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

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

4.2 Comum KaBuDa

/**
 * @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 Transfiguração 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 em execução

Como resultado, viu-se que Kabuda era constantemente decorado e, finalmente, atingiu o estado invencível de ter gigantes de Kabuda.

5 Simplificação do padrão decorador

Em circunstâncias normais, o padrão decorador não possui uma interface decorada abstrata, mas apenas um objeto decorado específico, considerando remover Componenta classe (interface) e tratá-la Decoratorcomo uma ConcreteComponentsubclasse. Como mostrado abaixo: