Java Reference
In-Depth Information
Composite
Pattern Properties
Type: Structural, Object
Level: Component
Purpose
To develop a flexible way to create hierarchical tree structures of arbitrary complexity, while enabling every
element in the structure to operate with a uniform interface.
Introduction
You've decided to enhance the Personal Information Manager to let users manage a complex project. Features of
this enhancement include defining the project as a group of tasks and related subtasks, and associating
deliverables with tasks. A natural way to accomplish this from a programming perspective is to define a tree
structure, where the root task (which represents the project itself) branches out to subprojects, subsubprojects, and
so on. Therefore, you define a
Task
class that holds a collection of other
Task
and
Deliverable
objects. Since
both the
Task
and
Deliverable
relate to the project, you define a common parent for them—the
ProjectItem
class.
However, what happens if users need to perform an action that depends on the whole tree? For example, a project
manager wants a time estimate for tasks and deliverables for one project. To accommodate this, you write code to
traverse the tree and call the appropriate methods at each branch. That's a lot of work, however, involving
separate code to walk the tree, call the methods, and collect the results. And with different classes (
Task
and
Deliverable
) at each branch of the tree, you might need to handle them differently when getting time estimates.
For a large number of classes or a complex tree, the code quickly becomes difficult to manage.
There's a better way to solve this problem. With the Composite pattern, you can use polymorphism and recursion
to provide an efficient, simple, easy-to-maintain solution.
Begin by defining a standard method for all classes that provides the time estimate, called
getTimeRequired
.
Define this method for the
ProjectItem
interface, and implement that behavior in all classes that are types of
ProjectItem
. For
Deliverable
, define
getTimeRequired
to return 0, because a deliverable does not have time
associated directly with it. For the
Task
class, return a time consisting of the time for the task plus the sum of the
getTimeRequired
calls for all of the
Task
children.
Using this pattern, you define
getTimeRequired
so that it automatically calculates the project time estimates for
any part of the tree. Just call the
getTimeRequired
method for the part of the
Task
needed, and the code in the
method takes care of the job of traversing the tree and calculating results.
Applicability
Use the Composite pattern when:
There is a component model with a branch-leaf structure (whole-part or container-contained).
The structure can have any level of complexity, and is dynamic.
You want to treat the component structure uniformly, using common operations throughout the hierarchy.
Description
Object-oriented developers are often interested in developing components that follow a whole-part model.
Whole-part model is a model that allows you to treat a collection of identical objects (the parts) as one entity (the
whole). Typically, these structures should be flexible and easy to use. Users should be able to modify the
structure as an application runs, adding or removing parts to suit their needs. At the same time, it's desirable to
keep the complexity of the structure hidden behind the scenes, so that users perceive only a seamless, unified
product.
