Patrón de diseño Composite (estructural)

Composite

Este útil patrón permite crear y manejar estructuras de objetos en forma de árbol, en las que un objeto puede contener a otro(s).

Patrón Composite en UML

En este punto cabe aclarar que las estructuras de este tipo se componen de nodos (un objeto que a su vez contiene otros objetos) y Hojas (objetos que no contienen otros), y que ambos comparten una misma Interface que define métodos que deben implementar.

Para ilustrar cómo funciona este patrón de diseño veamos a continuación un programa de ejemplo en el que gestionamos archivos y carpetas.

Main.java (Cliente según el diagrama anterior):

package estructurales.composite.composite01;

public class Main
{
    public static void main(String[] args)
    {
        // Crear la carpeta principal e insertar archivos
        Carpeta c1 = new Carpeta("CARPETA_1");
        c1.insertarNodo( new Archivo("Archivo1.txt") );
        c1.insertarNodo( new Archivo("Archivo2.txt") );
        c1.insertarNodo( new Archivo("Archivo3.txt") );

        // Crear una subcarpeta e insertar archivos
        Carpeta c2 = new Carpeta("CARPETA_2");
        c2.insertarNodo( new Archivo("Archivo4.txt") );
        c2.insertarNodo( new Archivo("Archivo5.txt") );

        // Insertar la subcarpeta dentro de la principal
        c1.insertarNodo( c2 );

        // Insertar otro archivo dentro de la carpeta principal
        c1.insertarNodo( new Archivo("Archivo6.txt") );

        c1.mostrar();

        System.out.println("--------------------");

        // Eliminamos la subcarpeta (junto con su contenido)
        c1.eliminarNodo( c2 );

        c1.mostrar();
    }
}

Nodo.java: (Componente según el diagrama anterior)

package estructurales.composite.composite01;

public abstract class Nodo
{
    public static final int ARCHIVO = 1;
    public static final int CARPETA = 2;

    protected String nombre = "";
    protected int tipoNodo;

    // ----------------------------

    public String getNombre()
    {
        return this.nombre;
    }

    // ----------------------------

    public void setNombre( String nombre )
    {
        this.nombre = nombre;
    }

    // ----------------------------

    public int getTipoNodo()
    {
        return this.tipoNodo;
    }

    // ----------------------------

    public void setTipoNodo( int tipoNodo )
    {
        this.tipoNodo = tipoNodo;
    }

    // ----------------------------

    // Método a implementar por las clases que hereden
    public abstract void mostrar();
}

Archivo.java: (Hoja según el diagrama anterior)

package estructurales.composite.composite01;

public class Archivo extends Nodo
{
    public Archivo( String nombre )
    {
        this.setTipoNodo( Nodo.ARCHIVO );
        this.setNombre( nombre );
    }

    // ----------------------------

    @Override
    public void mostrar()
    {
        System.out.println( "Archivo: [" + this.getNombre() + "]" );
    }
}

Carpeta.java: (Compuesto según el diagrama anterior)

package estructurales.composite.composite01;

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

public class Carpeta extends Nodo
{
    List<Nodo> nodos = new ArrayList<Nodo>();

    // ----------------------------

    public Carpeta( String nombre )
    {
        this.setTipoNodo( Nodo.CARPETA );
        this.setNombre( nombre );
    }

    // ----------------------------

    public void insertarNodo( Nodo nodo )
    {
        nodos.add( nodo );
    }

    // ----------------------------

    public void eliminarNodo( Nodo nodo )
    {
        nodos.remove( nodo );
    }

    // ----------------------------

    public List<Nodo> getNodos()
    {
        return nodos;
    }

    // ----------------------------

    public Nodo getNodo( int posicion )
    {
        return nodos.get( posicion );
    }

    // ----------------------------

    @Override
    public void mostrar()
    {
        System.out.println( "Listando carpeta [" + this.getNombre() + "]" );

        for (Nodo nodo : nodos)
        {
            nodo.mostrar();
        }
    }
}

Al ejecutarlo obtendríamos como resultado:

Ejemplo

EXPLICACIÓN:

Los archivos son hojas (no contienen otros elementos) y las carpetas serían nodos (pueden contener archivos así como otras carpetas).
Las clases Archivo y Carpeta heredan de la clase abstracta Nodo, que implementa los métodos comunes y define el método mostrar() que deberán implementar.
Dicho método en la clase Archivo abre el archivo para mostrar su contenido, y en la clase Carpeta muestra su contenido de forma recursiva (si contiene otras carpetas mostrará también lo que contienen).
Al ejecutar el programa se crea una carpeta principal y se le agregarán objetos de tipo Archivo así como otra subcarpeta que creamos posteriormente, y después mostramos su contenido.
A continuación eliminamos la subcarpeta y volvemos a mostrar el contenido de la principal

Veamos ahora otro ejemplo en el que se recorre cada elemento del árbol y se muestra el nombre del nodo padre de cada uno de ellos.

package estructurales.composite.composite02;

public class Main
{
    public static void main(String[] args)
    {
        // Crear la carpeta principal e insertar archivos
        Carpeta c1 = new Carpeta( "CARPETA_1", null );
        c1.insertarNodo( new Archivo("Archivo1.txt", c1) );
        c1.insertarNodo( new Archivo("Archivo2.txt", c1) );
        c1.insertarNodo( new Archivo("Archivo3.txt", c1) );

        // Crear una subcarpeta e insertar archivos
        Carpeta c2 = new Carpeta("CARPETA_2", c1);
        c2.insertarNodo( new Archivo("Archivo4.txt", c2) );
        c2.insertarNodo( new Archivo("Archivo5.txt", c2) );

        // Insertar la subcarpeta dentro de la principal
        c1.insertarNodo( c2 );

        // Insertar otro archivo dentro de la carpeta principal
        c1.insertarNodo( new Archivo("Archivo6.txt", c1) );

        c1.recorrerNodos();
    }
}