Patrones de Diseño - Patron Composite/Compuesto- ¿Que es el Patrón de Diseño Composite?

Hola siguiendo con nuestro curso de patrones de diseño hoy vamos a ver el Patrón Composite/Compuesto.

Patrones de  Diseño -  ¿Que es el Patrón de Diseño Composite?

El patrón Composite nos permite construir objetos complejos partiendo de otros más sencillos utilizando una estrategia de composición recursiva. Podemos equiparar este patrón a un panel y sus celdas. Cada objeto simple (celda) puede relacionarse con otros formando una estructura más compleja (panel). Lo podemos ver también como un libro cada hoja (objeto sencillo) se puede relacionar con otras hojas y forman un libro (objeto compuesto).

Combina objetos en estructuras de arbol para representar jerarquias de parte-todo. Permite que los clientes traten de manera uniforme a los objetos individuales y a los compuestos

Diagrama UML

Component: Declara la interfaz para los objetos de la composición, es la interfaz de acceso y manipulación de los componentes hijo e implementa algunos comportamientos por defecto.

Client: Manipula objetos atravez de la interfaz proporcionada por Component.

Composite: Define el comportamiento de los componentes compuestos, almacena a los hijos e implementa las operaciones de manejo de los componentes.

Leaf: Definen comportamientos para objetos primitivos del compuesto.

Nombre del patrón

Este patrón se lo suele llamar como composite, compuesto.

Clasificación del patrón:

Estructural

Intención:

Componer objetos en jerarquías parte-todo y permitir a los clientes tratar objetos simples y compuestos de modo uniforme.

Motivación:

Necesitamos representar un conjunto de elementos de una interfaz gráfica de usuario (GUI).

Algunos de estos elementos son simples, mientras que otros están formados por varios elementos más simples. El comportamiento y/o la información que proporciona un elemento complejo está determinada por los elementos que lo componen.

Ejemplo:

Problema: Actualmente a un escritor se le solicita escribir diferentes hojas, por cada hoja que escriba recibe un monto diferente y también se le solicita escribir un libro, pero se desconoce la cantidad de hojas que posee el libro, pero se requiere en algún momento solicitar el precio, ya sea de la hoja individual o del libro.

Solución:

Básicamente lo que necesitamos es que la hoja como el libro tenga  métodos común que sea obtener costo y agregar a la lista, el método obtener costos nos devuelve el costo ya sea por la hoja o por el libre, el libro debe poseer un lista de  AbstractCompositor a fin de agregar hoja por hoja.

Código fuente:

AbstractCompositor

package ar.com.patronesdisenio.compositor.base;
/**
 * @author nconde
 */
public abstract class AbstractCompositor {

   public abstract int getCosto();
   public abstract void agregarHoja(AbstractCompositor composicion);
}

Hoja

package ar.com.patronesdisenio.compositor.componentes;
import ar.com.patronesdisenio.compositor.base.AbstractCompositor;

/**
 * @author nconde
 */
public class Hoja extends AbstractCompositor {
 
 private int costo;
 public Hoja(int costo){
  this.costo = costo;
 }

 @Override
 public int getCosto() { 
  return this.costo;
 }

 @Override
 public void agregarHoja(AbstractCompositor composicion) {
  // metodo no se usa
 }
}

Libro

package ar.com.patronesdisenio.compositor.componentes;
import java.util.ArrayList;
import java.util.List;
import ar.com.patronesdisenio.compositor.base.AbstractCompositor;

/**
 * @author nconde
 */
public class Libro extends AbstractCompositor {
 
 private int costo = 0;
 private List<AbstractCompositor> listaComposicion;
 
 /**
  * Constructor
  */
 public Libro (){
  listaComposicion = new ArrayList<AbstractCompositor>();
 }
 
 /**
  * Obtiene el costo del libro
  */
 @Override
 public int getCosto() { 
  return this.costo;
 }
 
 /**
  * Agrega las hojas y calcula su valor rapidamente.
  * @param composicion
  */
 public void agregarHoja(AbstractCompositor composicion){
  this.costo = this.costo + composicion.getCosto();
  this.listaComposicion.add(composicion);
 }
}

Main

package ar.com.patronesdisenio.compositor.main;
import ar.com.patronesdisenio.compositor.base.AbstractCompositor;
import ar.com.patronesdisenio.compositor.componentes.Hoja;
import ar.com.patronesdisenio.compositor.componentes.Libro;

/**
 * @author nconde
 */
public class Main {

 /**
  * @param args
  */
 public static void main(String[] args) {
     AbstractCompositor componenteUno = new Hoja(10);

     System.out.println(componenteUno.getCosto());
     
     AbstractCompositor componenteTres = new Hoja(3);
     AbstractCompositor componenteDos = new Libro();
     
     componenteDos.agregarHoja(componenteUno);
     componenteDos.agregarHoja(componenteTres);
     
     System.out.println(componenteDos.getCosto());

 }
}

Bueno amigos espero que les allá quedado claro cualquier cosa me preguntan.