Ejemplos de utilización[editar]

En Java: las clases java.awt.Component (Componente),

java.awt.Container (Contenedor), java.awt.Panel (Contenedor concreto),
java.awt.Button (Botón)

Código en C++[editar]
#include <iostream>
#include <vector>

using namespace std;

class Component
{
protected:
string name;
public:
Component();
Component(string n);
virtual void add(Component*) {}
virtual void remove(Component*) {}
virtual void show(short) {}
};

Component::Component() {}
Component::Component(string n) : name(n) {}

class Composite : public Component

{
private:
vector<Component*> list;
public:
Composite(string);
void add(Component*);
void remove(Component*);
void show(short);
};

Composite::Composite(string n) { name = n; }
void Composite::add(Component* component)
{
list.push_back(component);
}
void Composite::remove(Component* component)
{
list.erase(std::remove(list.begin(), list.end(), component),
list.end());
}
void Composite::show(short depth)
{
cout << name << " nivel: " << depth << endl;
for(vector<Component*>::const_iterator iter = list.begin(); iter
!= list.end(); ++iter)
{
if(*iter != 0)
{
(*iter)->show(depth + 1);
}
}
}

class Leaf : public Component

{
public:
Leaf (string);
void add(Component*) {}
void remove(Component*) {}
void show(short);
};

Leaf::Leaf(string n) { name = n; }
void Leaf::show(short depth)
{
cout << '-' << name << " (" << depth << ')' << endl;
}

int main()
{
Composite* root = new Composite("raiz");
root->add(new Leaf("hoja A"));
root->add(new Leaf("hoja B"));

Composite* comp = new Composite("rama");

comp->add(new Leaf("hoja A'"));
comp->add(new Leaf("hoja B'"));

root->add(comp);
 root->add(new Leaf("hoja C"));
Leaf* h = new Leaf("hoja D");
root->add(h);
root->remove(h);
root->show(1);

delete h;
delete comp;
delete root;
return 0;
}

Código en Java[editar]
import java.util.*;

public abstract class Componente

{
protected String nombre;
public Componente (String nombre)
{
this.nombre = nombre;
}
abstract public void agregar(Componente c);
abstract public void eliminar(Componente c);
abstract public void mostrar(int profundidad);
}
class Compuesto extends Componente
{
private ArrayList<Componente> hijo = new
ArrayList<Componente>();
public Compuesto (String name)
{
super(name);
}
@Override
public void agregar(Componente componente)
{
hijo.add(componente);
}
@Override
public void eliminar(Componente componente)
{
 hijo.remove(componente);
}
@Override
public void mostrar(int profundidad)
{
System.out.println(nombre + " nivel: " + profundidad);
for (int i = 0; i < hijo.size(); i++)
hijo.get(i).mostrar(profundidad + 1);
}
}
class Hoja extends Componente
{
public Hoja (String nombre)
{
super(nombre);
}
public void agregar(Componente c)
{
System.out.println("no se puede agregar la hoja");
}
public void eliminar(Componente c)
{
System.out.println("no se puede quitar la hoja");
}
public void mostrar(int depth)
{
System.out.println('-' + "" + nombre);
}
}
public class Client
{
public static void main(String[] args)
{
Compuesto raiz = new Compuesto("root");
raiz.agregar(new Hoja("hoja A"));
raiz.agregar(new Hoja("hoja B"));
Compuesto comp = new Compuesto("compuesto X");
comp.agregar(new Hoja("hoja XA"));
comp.agregar(new Hoja("hoja XB"));
raiz.agregar(comp);
raiz.agregar(new Hoja("hoja C"));
Hoja l = new Hoja("hoja D");
raiz.agregar(l);
raiz.eliminar(l);
 raiz.mostrar(1);
}
}

Código completo en C#[editar]

using System;
using System.Collections.Generic;

namespace WikipediaCompositePattern
{
public class Program
{
static void Main(string[] args)
{
Compuesto raiz = new Compuesto("root");
raiz.Agregar(new Hoja("hoja A"));
raiz.Agregar(new Hoja("hoja B"));
Compuesto comp = new Compuesto("compuesto X");
comp.Agregar(new Hoja("hoja XA"));
comp.Agregar(new Hoja("hoja XB"));
raiz.Agregar(comp);
raiz.Agregar(new Hoja("hoja C"));
Hoja l = new Hoja("hoja D");
raiz.Agregar(l);
raiz.Eliminar(l);
raiz.Mostrar(1);
}
}

public abstract class Componente

{
protected string nombre;
public Componente (string nombre)
{
this.nombre = nombre;
}
public abstract void Agregar(Componente componente);
public abstract void Eliminar(Componente componente);
public abstract void Mostrar(int profundidad);
}
 public class Compuesto: Componente
{
private List<Componente> hijo = new List<Componente>();
public Compuesto (string nombre): base(nombre) { }
public override void Agregar(Componente componente)
{
hijo.Add(componente);
}
public override void Eliminar(Componente componente)
{
hijo.Remove(componente);
}
public override void Mostrar(int profundidad)
{
Console.WriteLine(string.Format("{0} nivel: {1}", nombre,
profundidad));
for (int i = 0; i < hijo.Count; i++)
hijo[i].Mostrar(profundidad + 1);
}
}

public class Hoja: Componente

{
public Hoja(string nombre): base(nombre) { }
public override void Agregar(Componente componente)
{
Console.WriteLine("no se puede agregar la hoja");
}
public override void Eliminar(Componente componente)
{
Console.WriteLine("no se puede eliminar la hoja");
}
public override void Mostrar(int profundidad)
{
Console.WriteLine(string.Format("-{0}", nombre));
}
}
}
https://es.wikipedia.org/wiki/Composite_(patr%C3%B3n_de_dise%C3%B1o)