Artículo

Patrón Composite en Java: estructuras en árbol con ejemplo

Qué es el patrón Composite en Java y cómo tratar igual a elementos simples y compuestos en una estructura de árbol, con un ejemplo ejecutable de menú.

En resumen: el patrón Composite organiza objetos en árbol y permite tratar igual a una hoja (un elemento simple) y a un contenedor (un grupo de elementos). Ambos implementan la misma interfaz; el contenedor delega en sus hijos. Así calculas el total de un menú, el tamaño de una carpeta o el precio de un pedido con subpedidos con una sola llamada, sin preguntar «¿esto es una hoja o un grupo?». Probado con Java 25, compatible desde Java 17.

Vídeo explicativo

Las tres piezas

PiezaEn el ejemploPapel
Componenteinterface ElementoMenuOperaciones comunes
Hojarecord PlatoElemento sin hijos
Compuestoclass SeccionContiene componentes y delega en ellos

Implementación

import java.util.ArrayList;
import java.util.List;

interface ElementoMenu {
    double precio();

    void imprimir(String sangria);
}

record Plato(String nombre, double precio) implements ElementoMenu {
    @Override
    public void imprimir(String sangria) {
        System.out.println(sangria + "- " + nombre + ": " + precio + " €");
    }
}

class Seccion implements ElementoMenu {
    private final String nombre;
    private final List<ElementoMenu> hijos = new ArrayList<>();

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

    Seccion anadir(ElementoMenu e) {
        hijos.add(e);
        return this;
    }

    @Override
    public double precio() {
        return hijos.stream().mapToDouble(ElementoMenu::precio).sum();
    }

    @Override
    public void imprimir(String sangria) {
        System.out.println(sangria + "+ " + nombre + " (total " + precio() + " €)");
        for (ElementoMenu e : hijos) {
            e.imprimir(sangria + "  ");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Seccion menu = new Seccion("Menú del día")
                .anadir(new Seccion("Entrantes")
                        .anadir(new Plato("Ensalada", 6.5))
                        .anadir(new Plato("Croquetas", 7.0)))
                .anadir(new Seccion("Principales")
                        .anadir(new Plato("Paella", 14.0))
                        .anadir(new Seccion("Del chef")
                                .anadir(new Plato("Lubina", 18.0))))
                .anadir(new Plato("Pan", 1.5));

        menu.imprimir("");
        System.out.println("Precio de todo: " + menu.precio() + " €");
    }
}

Salida:

+ Menú del día (total 47.0 €)
  + Entrantes (total 13.5 €)
    - Ensalada: 6.5 €
    - Croquetas: 7.0 €
  + Principales (total 32.0 €)
    - Paella: 14.0 €
    + Del chef (total 18.0 €)
      - Lubina: 18.0 €
  - Pan: 1.5 €
Precio de todo: 47.0 €

menu.precio() recorre el árbol entero por recursión: cada sección suma lo que le devuelven sus hijos, sean platos o secciones. El código cliente nunca comprueba tipos.

Dónde aparece en el mundo real

  • Sistemas de ficheros: un directorio contiene ficheros y directorios; el tamaño se calcula igual.
  • Interfaces gráficas: en Swing, un JPanel es un componente que contiene otros componentes.
  • Pedidos y presupuestos: líneas sueltas y paquetes de productos con descuento.
  • Reglas y permisos: una condición compuesta (Y, O) agrupa condiciones simples.
  • Árboles de categorías en una tienda o en un menú de navegación.

Decisiones de diseño

  • ¿Dónde van anadir y quitar? En el ejemplo, solo en Seccion: es más seguro (no puedes añadir hijos a un plato) a costa de que el cliente tenga que saber que está ante una sección para construir el árbol. La alternativa, ponerlos en la interfaz, da uniformidad pero obliga a las hojas a lanzar excepciones.
  • Interfaz sellada: con sealed interface ElementoMenu permits Plato, Seccion (Java 17) el compilador sabe que no hay más tipos, y un switch con patrones queda comprobado.
  • Árboles muy profundos: la recursión podría desbordar la pila con miles de niveles; para esos casos se recorre con una pila explícita.

Preguntas frecuentes

¿Composite y Decorator se parecen?

Ambos usan composición recursiva con la misma interfaz, pero un Decorator envuelve un objeto para añadirle comportamiento, mientras que un Composite agrupa varios para tratarlos como uno.

¿Se puede usar con JPA?

Sí: una entidad Categoria con @ManyToOne hacia su padre y @OneToMany hacia sus hijas es un Composite persistido. Cuidado con cargar el árbol completo de golpe; lo vemos en relaciones en JPA.

¿Por qué Plato es un record?

Porque es un valor inmutable sin lógica extra; los records pueden implementar interfaces. Más en records en Java.

Sigue aprendiendo

Otros patrones estructurales y de comportamiento: Observer, MVC y Prototype. El diseño orientado a objetos con patrones se trabaja en el curso de Java intermedio.

patrón composite patrones de diseño java árboles recursividad

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo