Composite and Prototype Design Pattern Example

In a Composite (or Decorator) structure, Prototype uses a prototypical instance to create new Composite Component. Composite is a structural pattern where as Prototype is creational pattern. They are related to each other in a sense that Prototype only make sense in the context of a structural pattern like Composite or Decorator.

Composite (source: GoF)

Prototype source: GoF

overview

​Composite pattern compose tree structures to represent part-whole hierarchies. It describes that a group of objects is to be treated in the same way as a single instance of an object through 'Component' interface. The code in the code example section show how Prototype makes sense Composite by mixing the Composite pattern and Prototype pattern.

For example, in the Game of Life, the universe of a Game of Life contains an outermost Cell. This outer most Cell is a composite Neighborhood which composes of other DEFAULT_GRID_SIZExDEFAULT_GRID_SIZE Neighborhoods. This outer most Cell is created via Prototype, recursively:

outermostCell = new Neighborhood
(DEFAULT_GRID_SIZE,
 // passed-in prototype
 new Neighborhood(DEFAULT_GRID_SIZE,
                  new Resident())       // passed-in prototype
);

code sample

Component/Prototype

public interface Cell
{
  Cell create();
  ...
}

Composite/ConcretePrototype

public final class Neighborhood implements Cell
{
  /** The actual grid of Cells contained within this neighborhood. */
  private final Cell[][] grid;
 
  /** The neighborhood is square, so gridSize is both the horizonta
   *  and vertical size.
   */
  private final int        gridSize;

  /** Create a new Neigborhood containing gridSize-by-gridSize
   *  clones of the prototype. The Protype is deliberately
   *  not put into the grid, so you can reuse it if you like.
   */
  public Neighborhood(int gridSize, Cell prototype)
  {
      this.gridSize = gridSize;
      this.grid = new Cell[gridSize][gridSize];
      for( int row = 0; row < gridSize; ++row )
        for( int column = 0; column < gridSize; ++column )
          grid[row][column] = prototype.create();
  }

  /** The "clone" method used to create copies of the current
   *  neighborhood. This method is called from the containing
   *  neighborhood's constructor.
   */
    public Cell create()
    {    return new Neighborhood(gridSize, grid[0][0]);
    }
  ...
}
​

Leaf/ConcretePrototype

public final class Resident implements Cell
{
  private static final Color BORDER_COLOR = Colors.DARK_YELLOW;
  private static final Color LIVE_COLOR     = Color.RED;
  private static final Color DEAD_COLOR   = Colors.LIGHT_YELLOW;
  private boolean amAlive     = false;
  private boolean willBeAlive    = false;
  ...
  public Cell create(){    // The "clone" method
    return new Resident(); 
  }
  ...
}

when to use

1. Prototype only make sense in the context of a structural pattern like Composite or Decorator.
2. You want to form a composite object with a prototype (a library of reusable objects) and the prototype itself may need to be formed from another prototype recursively.

comparison

Factory Method vs. Prototype

references

The Game of Life