Patrón Composite

Trata igual a un objeto suelto y a un grupo de objetos organizados en árbol: carpetas y ficheros, capítulos y partidas, menús y submenús. Cada operación se resuelve con una llamada recursiva.

nivel intermedioTambién: compuesto, árbol de objetos, parte-todo

Visualízalo paso a paso

Cambia los datos, dale a reproducir y sigue cada paso en el dibujo, en la línea de Java que se ejecuta y en sus variables.

Composite

Escribe un árbol de carpetas y ficheros: carpeta(...) contiene elementos separados por comas y fichero:KB es un fichero con su tamaño.

proyecto.tamano()

esperando a sus hijos

Velocidad

Paso 1

proyecto/ es una carpeta: empieza con total = 0 y pide el tamaño a cada uno de sus 3 elementos, sin saber si son ficheros o carpetas.

1class Fichero implements Elemento {
2    public long tamano() {
3        return kb;
4    }
5}
6
7class Carpeta implements Elemento {
8    public long tamano() {
9        long total = 0;  // llamadas abiertas = proyecto, total = 0 KB
10        for (Elemento e : hijos)
11            total += e.tamano();
12        return total;
13    }
14}

Variables

llamadas abiertas: proyecto
total: 0 KB

Atajos con el foco dentro del visualizador: ← → paso a paso, Espacio reproducir o pausar, Inicio/Fin ir al principio o al final.

La idea

Una carpeta contiene ficheros y otras carpetas, que a su vez contienen más. Para saber cuánto ocupa una carpeta hay que sumar sus ficheros y, para cada subcarpeta, repetir lo mismo. Si el código distingue a cada paso «si es un fichero haz esto, si es una carpeta haz lo otro», se llena de instanceof y de casos.

El patrón Composite da a la hoja (Fichero) y al compuesto (Carpeta) la misma interfaz (Elemento). El compuesto guarda una lista de Elemento y resuelve cada operación preguntando a sus hijos: tamano() de una carpeta es la suma de tamano() de lo que contiene, sin saber si son ficheros o carpetas. La recursión sale sola.

El cliente trata igual a un fichero que a un árbol entero: llama a tamano() o a mostrar() y ya está. Lo verás en los sistemas de ficheros, en el DOM de una página web (un elemento contiene elementos), en las interfaces gráficas (un panel contiene botones y otros paneles), en los menús y en los presupuestos por capítulos.

Cuándo usarlo

Los datos forman un árbol de partes y todos (carpetas, menús, organigramas, presupuestos, el DOM).
Quieres que el cliente trate igual a un elemento suelto y a un grupo.
Las operaciones se calculan combinando el resultado de los hijos (sumar, contar, buscar, pintar).

Cuándo no

Si la estructura no es un árbol o solo tiene un nivel: una lista basta.
Si las hojas y los compuestos casi no tienen operaciones en común: la interfaz común acaba con métodos que no tienen sentido para unos u otros.

Participantes

Componente. La interfaz común a hojas y compuestos (Elemento) con las operaciones del árbol.
Hoja. El elemento sin hijos (Fichero): resuelve cada operación por sí mismo.
Compuesto. El elemento con hijos (Carpeta): guarda una lista de componentes y resuelve cada operación llamando a sus hijos.
Cliente. Trabaja con la interfaz común, sin distinguir hojas de compuestos.

Diagrama de clases

Arrastra las clases para colocarlas a tu gusto.

Ver el diagrama en PlantUML

text

1@startuml
2interface Elemento {
3  +nombre() : String
4  +tamano() : long
5  +mostrar(sangria : String) : void
6}
7class Fichero {
8  -kb : long
9}
10class Carpeta {
11  -hijos : List<Elemento>
12  +anadir(e : Elemento) : Carpeta
13}
14Elemento <|.. Fichero
15Elemento <|.. Carpeta
16Carpeta o-- "0..*" Elemento : hijos
17@enduml

Puedes copiarlo en el editor de diagramas UML y modificarlo.

El código

Carpetas y ficheros

tamano() y mostrar() de una carpeta llaman a los de sus hijos: la recursión recorre todo el árbol sin un solo instanceof.

Java
import java.util.*;

/** El componente: lo que tienen en común un fichero y una carpeta. */
interface Elemento {
    String nombre();
    long tamano();                                     // en KB
    void mostrar(String sangria);
}

/** Una hoja: no contiene nada. */
class Fichero implements Elemento {
    private final String nombre;
    private final long kb;
    Fichero(String nombre, long kb) { this.nombre = nombre; this.kb = kb; }
    public String nombre() { return nombre; }
    public long tamano() { return kb; }
    public void mostrar(String sangria) { System.out.println(sangria + nombre + " (" + kb + " KB)"); }
}

/** El compuesto: contiene elementos, que pueden ser ficheros u otras carpetas. */
class Carpeta implements Elemento {
    private final String nombre;
    private final List<Elemento> hijos = new ArrayList<>();

    Carpeta(String nombre) { this.nombre = nombre; }

    Carpeta anadir(Elemento e) { hijos.add(e); return this; }

    public String nombre() { return nombre; }

    public long tamano() {
        long total = 0;
        for (Elemento e : hijos) total += e.tamano();  // la misma llamada para ficheros y carpetas
        return total;
    }

    public void mostrar(String sangria) {
        System.out.println(sangria + nombre + "/ (" + tamano() + " KB)");
        for (Elemento e : hijos) e.mostrar(sangria + "  ");
    }
}

public class Main {
    public static void main(String[] args) {
        Carpeta proyecto = new Carpeta("proyecto")
                .anadir(new Fichero("README.md", 4))
                .anadir(new Carpeta("src")
                        .anadir(new Fichero("Main.java", 12))
                        .anadir(new Carpeta("modelo")
                                .anadir(new Fichero("Alumno.java", 6))
                                .anadir(new Fichero("Curso.java", 5))))
                .anadir(new Carpeta("docs"));
        proyecto.mostrar("");
        Elemento suelto = new Fichero("notas.txt", 2);
        System.out.println("Un fichero suelto también es un Elemento: " + suelto.tamano() + " KB");
    }
}

from abc import ABC, abstractmethod


class Elemento(ABC):
    """El componente: lo que tienen en común un fichero y una carpeta."""
    @abstractmethod
    def tamano(self): ...                      # en KB

    @abstractmethod
    def mostrar(self, sangria): ...


class Fichero(Elemento):
    """Una hoja: no contiene nada."""
    def __init__(self, nombre, kb):
        self.nombre, self.kb = nombre, kb

    def tamano(self):
        return self.kb

    def mostrar(self, sangria):
        print(f"{sangria}{self.nombre} ({self.kb} KB)")


class Carpeta(Elemento):
    """El compuesto: contiene elementos, que pueden ser ficheros u otras carpetas."""
    def __init__(self, nombre):
        self.nombre = nombre
        self.hijos = []

    def anadir(self, e):
        self.hijos.append(e)
        return self

    def tamano(self):
        return sum(e.tamano() for e in self.hijos)    # la misma llamada para ficheros y carpetas

    def mostrar(self, sangria):
        print(f"{sangria}{self.nombre}/ ({self.tamano()} KB)")
        for e in self.hijos:
            e.mostrar(sangria + "  ")


proyecto = (Carpeta("proyecto")
            .anadir(Fichero("README.md", 4))
            .anadir(Carpeta("src")
                    .anadir(Fichero("Main.java", 12))
                    .anadir(Carpeta("modelo")
                            .anadir(Fichero("Alumno.java", 6))
                            .anadir(Fichero("Curso.java", 5))))
            .anadir(Carpeta("docs")))
proyecto.mostrar("")
suelto = Fichero("notas.txt", 2)
print(f"Un fichero suelto también es un Elemento: {suelto.tamano()} KB")

/** Una hoja: no contiene nada. */
class Fichero {
    constructor(nombre, kb) { this.nombre = nombre; this.kb = kb; }
    tamano() { return this.kb; }
    mostrar(sangria) { console.log(`${sangria}${this.nombre} (${this.kb} KB)`); }
}

/** El compuesto: contiene elementos, que pueden ser ficheros u otras carpetas. */
class Carpeta {
    constructor(nombre) { this.nombre = nombre; this.hijos = []; }

    anadir(e) { this.hijos.push(e); return this; }

    tamano() {
        return this.hijos.reduce((total, e) => total + e.tamano(), 0);   // la misma llamada para todos
    }

    mostrar(sangria) {
        console.log(`${sangria}${this.nombre}/ (${this.tamano()} KB)`);
        for (const e of this.hijos) e.mostrar(sangria + "  ");
    }
}

const proyecto = new Carpeta("proyecto")
    .anadir(new Fichero("README.md", 4))
    .anadir(new Carpeta("src")
        .anadir(new Fichero("Main.java", 12))
        .anadir(new Carpeta("modelo")
            .anadir(new Fichero("Alumno.java", 6))
            .anadir(new Fichero("Curso.java", 5))))
    .anadir(new Carpeta("docs"));
proyecto.mostrar("");
const suelto = new Fichero("notas.txt", 2);
console.log(`Un fichero suelto también es un Elemento: ${suelto.tamano()} KB`);

using System;
using System.Collections.Generic;
using System.Linq;

// El componente: lo que tienen en común un fichero y una carpeta.
interface IElemento {
    long Tamano();                                     // en KB
    void Mostrar(string sangria);
}

// Una hoja: no contiene nada.
class Fichero : IElemento {
    private readonly string nombre;
    private readonly long kb;
    public Fichero(string nombre, long kb) { this.nombre = nombre; this.kb = kb; }
    public long Tamano() => kb;
    public void Mostrar(string sangria) => Console.WriteLine(quot;{sangria}{nombre} ({kb} KB)");
}

// El compuesto: contiene elementos, que pueden ser ficheros u otras carpetas.
class Carpeta : IElemento {
    private readonly string nombre;
    private readonly List<IElemento> hijos = new();
    public Carpeta(string nombre) => this.nombre = nombre;

    public Carpeta Anadir(IElemento e) { hijos.Add(e); return this; }

    public long Tamano() => hijos.Sum(e => e.Tamano());   // la misma llamada para ficheros y carpetas

    public void Mostrar(string sangria) {
        Console.WriteLine(quot;{sangria}{nombre}/ ({Tamano()} KB)");
        foreach (var e in hijos) e.Mostrar(sangria + "  ");
    }
}

class Program {
    static void Main() {
        var proyecto = new Carpeta("proyecto")
            .Anadir(new Fichero("README.md", 4))
            .Anadir(new Carpeta("src")
                .Anadir(new Fichero("Main.java", 12))
                .Anadir(new Carpeta("modelo")
                    .Anadir(new Fichero("Alumno.java", 6))
                    .Anadir(new Fichero("Curso.java", 5))))
            .Anadir(new Carpeta("docs"));
        proyecto.Mostrar("");
        IElemento suelto = new Fichero("notas.txt", 2);
        Console.WriteLine(quot;Un fichero suelto también es un Elemento: {suelto.Tamano()} KB");
    }
}

<?php
/** El componente: lo que tienen en común un fichero y una carpeta. */
interface Elemento {
    public function tamano(): int;                     // en KB
    public function mostrar(string $sangria): void;
}

/** Una hoja: no contiene nada. */
class Fichero implements Elemento {
    public function __construct(private string $nombre, private int $kb) {}
    public function tamano(): int { return $this->kb; }
    public function mostrar(string $sangria): void { echo "$sangria{$this->nombre} ({$this->kb} KB)\n"; }
}

/** El compuesto: contiene elementos, que pueden ser ficheros u otras carpetas. */
class Carpeta implements Elemento {
    private array $hijos = [];
    public function __construct(private string $nombre) {}

    public function anadir(Elemento $e): self { $this->hijos[] = $e; return $this; }

    public function tamano(): int {
        return array_sum(array_map(fn (Elemento $e) => $e->tamano(), $this->hijos));   // la misma llamada para todos
    }

    public function mostrar(string $sangria): void {
        echo "$sangria{$this->nombre}/ ({$this->tamano()} KB)\n";
        foreach ($this->hijos as $e) $e->mostrar($sangria . "  ");
    }
}

$proyecto = (new Carpeta("proyecto"))
    ->anadir(new Fichero("README.md", 4))
    ->anadir((new Carpeta("src"))
        ->anadir(new Fichero("Main.java", 12))
        ->anadir((new Carpeta("modelo"))
            ->anadir(new Fichero("Alumno.java", 6))
            ->anadir(new Fichero("Curso.java", 5))))
    ->anadir(new Carpeta("docs"));
$proyecto->mostrar("");
$suelto = new Fichero("notas.txt", 2);
echo "Un fichero suelto también es un Elemento: {$suelto->tamano()} KB\n";

Salida al ejecutarlo (la misma en los 5 lenguajes)

proyecto/ (27 KB)
  README.md (4 KB)
  src/ (23 KB)
    Main.java (12 KB)
    modelo/ (11 KB)
      Alumno.java (6 KB)
      Curso.java (5 KB)
  docs/ (0 KB)
Un fichero suelto también es un Elemento: 2 KB

Una interfaz gráfica es un Composite

Un panel es un componente que contiene componentes: se añade a la ventana como un botón más.

Java
// Las interfaces gráficas son un Composite: un panel es un componente que contiene componentes
JPanel formulario = new JPanel(new GridLayout(0, 2));
formulario.add(new JLabel("Nombre"));
formulario.add(new JTextField(20));

JPanel botones = new JPanel();
botones.add(new JButton("Aceptar"));
botones.add(new JButton("Cancelar"));

JFrame ventana = new JFrame("Alta de alumno");
ventana.add(formulario, BorderLayout.CENTER);
ventana.add(botones, BorderLayout.SOUTH);        // un panel dentro de la ventana, como un botón más
ventana.pack();                                   // calcula el tamaño de todo el árbol
ventana.setVisible(true);                         // y lo pinta, de la raíz a las hojas

import tkinter as tk

# En tkinter, un Frame es un componente que contiene componentes
ventana = tk.Tk()
formulario = tk.Frame(ventana)
tk.Label(formulario, text="Nombre").grid(row=0, column=0)
tk.Entry(formulario).grid(row=0, column=1)

botones = tk.Frame(ventana)
tk.Button(botones, text="Aceptar").pack(side="left")
tk.Button(botones, text="Cancelar").pack(side="left")

formulario.pack()
botones.pack()                 # un marco dentro de la ventana, como un botón más
ventana.mainloop()

// El DOM es un Composite: un elemento contiene nodos, que pueden ser texto u otros elementos
const formulario = document.createElement("form");
const campo = document.createElement("input");
const botones = document.createElement("div");
botones.append(Object.assign(document.createElement("button"), { textContent: "Aceptar" }));
formulario.append(campo, botones);           // un div con botones dentro, como un campo más
document.body.append(formulario);

// Las operaciones funcionan igual sobre una hoja o sobre un subárbol entero
console.log(formulario.textContent);         // junta el texto de todos sus descendientes
formulario.remove();                          // y quita el subárbol completo

// En Windows Forms, un Panel es un control que contiene controles
var formulario = new TableLayoutPanel { ColumnCount = 2 };
formulario.Controls.Add(new Label { Text = "Nombre" });
formulario.Controls.Add(new TextBox());

var botones = new FlowLayoutPanel();
botones.Controls.Add(new Button { Text = "Aceptar" });
botones.Controls.Add(new Button { Text = "Cancelar" });

var ventana = new Form { Text = "Alta de alumno" };
ventana.Controls.Add(formulario);
ventana.Controls.Add(botones);              // un panel dentro de la ventana, como un botón más

<?php
// DOMDocument: un elemento contiene nodos, que pueden ser texto u otros elementos
$doc = new DOMDocument();
$form = $doc->createElement("form");
$botones = $doc->createElement("div");
$botones->appendChild($doc->createElement("button", "Aceptar"));
$form->appendChild($doc->createElement("input"));
$form->appendChild($botones);               // un div con botones dentro, como un campo más
$doc->appendChild($form);
echo $doc->saveHTML();

En la práctica

El DOM: cada elemento HTML contiene nodos (texto u otros elementos) y textContent o remove() funcionan igual en una hoja que en un subárbol.
Swing, JavaFX y Android: JPanel, Pane y ViewGroup son componentes que contienen componentes.
Los sistemas de ficheros (java.io.File, Path) y los menús con submenús de cualquier aplicación.
Los presupuestos por capítulos, los organigramas, las categorías de una tienda y las expresiones matemáticas ((2 + 3) * x es un árbol).

Errores típicos

Recorrer el árbol desde fuera con instanceof en lugar de dejar que cada nodo resuelva la operación.
Olvidar el caso del compuesto vacío: una carpeta sin nada debe dar 0, no un error.
Crear ciclos (meter una carpeta dentro de sí misma o de un descendiente): la recursión no termina.
Poner en la interfaz común métodos de compuesto (anadir) y hacer que las hojas lancen excepciones: mejor dejarlos solo en el compuesto.

Ejercicios

Cada ejercicio se corrige solo con sus pruebas (algunas ocultas). Escribe tu solución en el editor y pulsa Ejecutar o Comprobar; la solución explicada está debajo, por si te atascas.

1. Presupuesto de una obra

Un presupuesto se organiza en capítulos que contienen partidas y otros capítulos. Las partidas ya calculan su total y se muestran; el main ya crea el árbol. Completa total() y mostrar() de Capitulo para que trabajen con todo lo que contienen.

Órdenes: capitulo ruta (como Cocina o Cocina/Muebles), partida ruta nombre cantidad precio, total ruta (escribe Total de ruta: X €) y mostrar (todo el presupuesto desde Obra).
mostrar: cada capítulo como nombre: total € y, dos espacios más adentro, cada cosa que contiene en el orden en que se añadió; una partida es nombre: cantidad × precio € = total €.

JavaPresupuesto de una obraFácil

Ejemplo

Entrada (lo que se escribe por teclado)

capitulo Cocina
capitulo Cocina/Muebles
partida Cocina/Muebles Encimera 3 120.50
partida Cocina/Muebles Armario 2 89
partida Cocina Pintura 25 8
capitulo Bano
partida Bano Plato 1 340
total Cocina
total Cocina/Muebles
mostrar

Salida esperada

Total de Cocina: 739,50 €
Total de Cocina/Muebles: 539,50 €
Obra: 1079,50 €
  Cocina: 739,50 €
    Muebles: 539,50 €
      Encimera: 3 × 120,50 € = 361,50 €
      Armario: 2 × 89,00 € = 178,00 €
    Pintura: 25 × 8,00 € = 200,00 €
  Bano: 340,00 €
    Plato: 1 × 340,00 € = 340,00 €

Una cocina y un baño

Rutas que no existen

Test oculto #3

Test oculto #4

0/4 tests pasados · pulsa un test para ver su entrada y su salida esperada

Ver la solución explicada

java
import java.util.*;

/** Lo que tienen en común una partida y un capítulo del presupuesto. */
interface Concepto {
    String nombre();
    double total();
    void mostrar(String sangria);
}

/** Una hoja: una partida con su cantidad y su precio por unidad. */
class Partida implements Concepto {
    private final String nombre;
    private final double cantidad, precio;
    Partida(String nombre, double cantidad, double precio) { this.nombre = nombre; this.cantidad = cantidad; this.precio = precio; }
    public String nombre() { return nombre; }
    public double total() { return cantidad * precio; }
    public void mostrar(String sangria) {
        System.out.println(sangria + nombre + ": " + Main.num(cantidad) + " × " + Main.euros(precio) + " = " + Main.euros(total()));
    }
}

/** El compuesto: un capítulo contiene partidas y otros capítulos. */
class Capitulo implements Concepto {
    private final String nombre;
    private final List<Concepto> hijos = new ArrayList<>();
    Capitulo(String nombre) { this.nombre = nombre; }
    public String nombre() { return nombre; }
    void anadir(Concepto c) { hijos.add(c); }

    /** El hijo con ese nombre, o null. */
    Concepto hijo(String nombre) {
        for (Concepto c : hijos) if (c.nombre().equals(nombre)) return c;
        return null;
    }

    public double total() {
        double suma = 0;
        for (Concepto c : hijos) suma += c.total();      // partidas y capítulos, igual
        return suma;
    }

    public void mostrar(String sangria) {
        System.out.println(sangria + nombre + ": " + Main.euros(total()));
        for (Concepto c : hijos) c.mostrar(sangria + "  ");
    }
}

public class Main {
    static String euros(double x) {
        return String.format(Locale.ROOT, "%.2f", x).replace('.', ',') + " €";
    }

    static String num(double x) {
        return x == Math.rint(x) ? String.valueOf((long) x) : String.valueOf(x).replace('.', ',');
    }

    /** El capítulo de una ruta («Cocina/Muebles»), o null si no existe. */
    static Capitulo buscar(Capitulo raiz, String ruta) {
        Capitulo actual = raiz;
        if (ruta.equals("Obra")) return raiz;
        for (String parte : ruta.split("/")) {
            if (!(actual.hijo(parte) instanceof Capitulo c)) return null;
            actual = c;
        }
        return actual;
    }

    public static void main(String[] args) {
        Capitulo obra = new Capitulo("Obra");
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String linea = sc.nextLine().trim();
            if (linea.isEmpty()) continue;
            String[] p = linea.split("\\s+");
            try {
                switch (p[0] + "/" + (p.length - 1)) {
                    case "capitulo/1" -> {
                        int barra = p[1].lastIndexOf('/');
                        Capitulo padre = barra < 0 ? obra : buscar(obra, p[1].substring(0, barra));
                        String nombre = p[1].substring(barra + 1);
                        if (padre == null) System.out.println("No existe el capítulo: " + p[1].substring(0, barra));
                        else if (padre.hijo(nombre) != null) System.out.println("Ya existe: " + p[1]);
                        else padre.anadir(new Capitulo(nombre));
                    }
                    case "partida/4" -> {
                        Capitulo c = buscar(obra, p[1]);
                        if (c == null) System.out.println("No existe el capítulo: " + p[1]);
                        else c.anadir(new Partida(p[2], Double.parseDouble(p[3]), Double.parseDouble(p[4])));
                    }
                    case "total/1" -> {
                        Capitulo c = buscar(obra, p[1]);
                        System.out.println(c == null ? "No existe el capítulo: " + p[1] : "Total de " + p[1] + ": " + euros(c.total()));
                    }
                    case "mostrar/0" -> obra.mostrar("");
                    default -> System.out.println("Orden no válida: " + linea);
                }
            } catch (NumberFormatException e) {
                System.out.println("Orden no válida: " + linea);
            }
        }
    }
}

Cada capítulo solo conoce a sus hijos directos; la recursión baja sola hasta las partidas.

El main pide el total de un capítulo o de la obra entera con la misma llamada.

2. Menús con submenús

La barra de menús de una aplicación es un árbol: menús que contienen acciones y otros menús. Ya está la hoja, Accion. Completa Menu para que cuente, busque, se desactive y se muestre con todo lo que contiene.

Órdenes: menu ruta y accion ruta (crean un menú o una acción, como Archivo/Recientes), contar (Acciones activas: n de m), buscar texto (la ruta Menú > Submenú > Acción de cada acción activa que contiene el texto, sin distinguir mayúsculas, en orden), desactivar ruta y mostrar.
Desactivar un menú desactiva todo lo que contiene. mostrar escribe cada menú como nombre > y cada acción como - nombre, dos espacios más adentro por nivel, con (desactivado) o (desactivada) cuando toca.

JavaMenús con submenúsMedio