1.3 Composite design pattern

Description

The Composite Design Pattern allows a client object to treat both single components and collections of components identically.    It accomplishes this by creating an abstraction that unifies both the single components and composed collections as abstract equivalents. Mathematically, we say that the single components and composed collections are homomorphically equivalent (from the Latin: homo – same and morph – form ==>to have the same form).

This equivalence of single and composite components is what we call a recursive data structure . In recursive data structures, objects are linked to other objects to create a total object structure made of many “nodes” (objects). Since every node is abstractly equivalent, the entire, possibly infinitely large and complex data structure can be succinctly described in terms of just three distinct things: the single components, the composite components and their abstract representation. This massive reduction in complexity is one of the cornerstones of computer science.

The Composite Design Pattern is an object-oriented representation of a recursive data structure.

Uml diagram and example

In the UML class diagram below, the Client uses an abstract component, AComponent , for some abstract task, operation() .   At run-time, the Client may hold a reference to a concrete component such as Leaf1 or Leaf2 .   When the operation task is requested by the Client , the specific concrete behavior with the particular concrete component referenced will be performed.    

The Composite class is a concrete component like Leaf1 and Leaf2 , but has no operation() behavior of its own.    Instead, Composite is composed with a collection of other abstract components, which may be of any other concrete component type including the composite itself.   The unifying fact is that they are all abstractly AComponent s.   When the operation() method of a Composite object is called, it simply dispatches the request sequentially to all of its "children" components and perhaps, also does some additional computations itself.     For instance, a Composite object could hold references to both a Leaf1 and a Leaf2  instance.   If a client holds a reference to that  Composite object and calls its operation() method, the Composite object will first call operation on its Leaf1 instance and then operation() on its Leaf2 instance.   Thus composite behavior of  Leaf1 plus Leaf2 behaviors is achieved without either duplicating code or by having the Client object knowing that the two leaf components were involved.  

Composite patterns are often used to represent recursive data structures.    The recursive nature of the Composite structure naturally gives way to recursive code to process that structure.

In Design Patterns , the abstract component AComponent is shown as having accessor methods for child AComponent s.   They are not shown here because it is debatable as to whether one wants the Client to fundamentally view the AComponent as a single component or as a collection of components.   Design Patterns models all AComponent s as collections while the above design models them all as single components.   The exact nature of those accessor methods is also debatable.