DS & II

Capítulo 13 - Composite

Leitura de 4 min

🚀 Capítulo 13: Composite (Tema: RPG / Árvore de Talentos)

NOTE

Este capítulo utiliza a temática de RPG para explicar o padrão Composite. Uma habilidade pode ser um golpe simples ou uma árvore inteira de magias; o padrão permite tratar ambos da mesma forma!

1. 🎯 Objetivo da Aula

Compreender o padrão de projeto Composite (Padrão Estrutural), entendendo como ele permite tratar objetos individuais e composições de objetos de maneira uniforme (como uma estrutura de árvore).

2. 🏢 O Cenário Prático (Seu Desafio)

Você está criando o sistema de Árvore de Talentos de um RPG.

  • Um talento pode ser uma Habilidade Simples (Ex: “Ataque Forte” que custa 10 pontos).
  • Ou pode ser um Ramo de Habilidades (Ex: “Magias de Fogo” que contém “Bola de Fogo”, “Muralha de Chamas” e até outro sub-ramo de “Magias Proibidas”).

O jogador quer saber quantos pontos de talento gastou no total.

  • Se for uma habilidade simples, o sistema retorna o custo dela.
  • Se for um ramo, o sistema precisa somar o custo de todas as habilidades que estão dentro dele.

O padrão Composite permite que você trate tanto a habilidade simples quanto o ramo da mesma forma, chamando o método calcularCusto(). O próprio ramo se encarrega de perguntar o custo de seus filhos e somar! Seu desafio é estruturar essa árvore!

3. 🧠 Fundamentos: A Teoria Traduzida

O Composite (Composto) é um padrão de projeto estrutural que permite que você componha objetos em estruturas de árvore e então trabalhe com essas estruturas como se elas fossem objetos individuais.

🌳 Componentes da Árvore:

  1. Componente (Interface): Declara as operações comuns (Ex: calcularCusto()).
  2. Folha (Leaf): Objeto simples que não tem filhos (Ex: Habilidade Simples). Ele realmente executa o trabalho.
  3. Composto (Composite): Objeto que contém filhos (podem ser folhas ou outros compostos). Ele delega o trabalho para seus filhos e resume o resultado.

4. 📖 Exemplo Guiado: Árvore de Talentos (JS)

// Interface comum (conceitual)
class ComponenteTalento {
    calcularCusto() {}
}
 
// FOLHA (Objeto Simples)
class HabilidadeSimples extends ComponenteTalento {
    constructor(nome, custo) {
        super();
        this.nome = nome;
        this.custo = custo;
    }
    calcularCusto() { return this.custo; }
}
 
// COMPOSTO (Objeto que contém outros)
class RamoDeTalentos extends ComponenteTalento {
    constructor(nome) {
        super();
        this.nome = nome;
        this.filhos = [];
    }
 
    adicionar(componente) { this.filhos.push(componente); }
 
    calcularCusto() {
        // Soma o custo de todos os filhos (recursivamente!)
        return this.filhos.reduce((total, filho) => total + filho.calcularCusto(), 0);
    }
}
 
// USO
const ataqueForte = new HabilidadeSimples("Ataque Forte", 10);
const bolaDeFogo = new HabilidadeSimples("Bola de Fogo", 15);
const paredeDeFogo = new HabilidadeSimples("Parede de Fogo", 20);
 
const ramoFogo = new RamoDeTalentos("Ramo de Fogo");
ramoFogo.adicionar(bolaDeFogo);
ramoFogo.adicionar(paredeDeFogo);
 
console.log(`Custo do Ataque Forte: ${ataqueForte.calcularCusto()}`); // 10
console.log(`Custo do Ramo de Fogo: ${ramoFogo.calcularCusto()}`); // 35 (15 + 20)

5. 🛠️ Prática Obrigatória 1: Ramificando Mais

Com base no exemplo acima, crie mentalmente (ou no código) um novo ramo chamado "Árvore Completa".

  1. Adicione o ataqueForte e o ramoFogo dentro desse novo ramo.
  2. Qual será o resultado de arvoreCompleta.calcularCusto()?

6. 🛠️ Prática Obrigatória 2: Pastas e Arquivos

Dizemos que o padrão Composite é perfeito para representar o sistema de arquivos do seu computador.

  1. Nesse sistema, quem seriam as Folhas?
  2. Quem seriam os Compostos?
  3. Qual operação comum (método) poderíamos chamar em ambos? (Ex: Calcular tamanho).

7. 📤 Instruções de Entrega (GitHub Desktop + Microsoft Teams)

  1. Faça o Commit: No GitHub Desktop, digite a mensagem (ex: Finaliza Capítulo 13 Paradigmas) e clique em Commit to main.
  2. Envie para a Nuvem (Push): Clique em Push origin.

8. 📂 Estrutura de Pastas

mod_10_paradigmas_e_padroes_de_projeto/
├── capitulos/
│   ├── capitulo_13_composite.md
│   └── codigos/
│       └── cap13/
│           └── arvore_talentos.js

9. 💡 Checkpoint de Lógica

O padrão Composite usa Recursão por baixo dos panos. Quando o Ramo chama calcularCusto() de um filho que também é um Ramo, o processo se repete até chegar nas Folhas!

10. 🔥 Desafio de Fixação

Pesquise como o padrão Composite é usado em frameworks de interface gráfica (como o HTML/DOM ou o Flutter), onde um componente visual pode conter outros componentes dentro dele.

🔑 Gabarito de Código/Fórmulas

Gabarito da Prática 1: 2. O custo total será 45 (10 do ataque forte + 35 do ramo de fogo). O próprio padrão soma tudo! Gabarito da Prática 2:

  1. As Folhas seriam os Arquivos (imagens, textos, etc.).
  2. Os Compostos seriam as Pastas (que podem conter arquivos ou outras pastas).
  3. Operação comum: calcularTamanho() ou deletar().

← Capitulo Anterior | Proximo Capitulo →

Visão de gráfico

Backlinks