The

Composite
Pattern

Design Patterns In Java Bob Tarr

The Composite Pattern

l Intent
é Compose objects into tree structures to represent part-whole hierarchies.
Composite lets clients treat individual objects and compositions of objects
uniformly. This is called recursive composition.
l Motivation

Design Patterns In Java

The Composite Pattern Bob Tarr
2

1
 The Composite Pattern

l Motivation

l Applicability
Use the Composite pattern when
é You want to represent part-whole hierarchies of objects
é You want clients to be able to ignore the difference between compositions
of objects and individual objects. Clients will treat all objects in the
composite structure uniformly.
Design Patterns In Java
The Composite Pattern Bob Tarr
3

The Composite Pattern

l Structure

Design Patterns In Java

The Composite Pattern Bob Tarr
4

2
 The Composite Pattern

l Consequences
é Benefits
Ý It makes it easy to add new kinds of components
Ý It makes clients simpler, since they do not have to know if they are dealing
with a leaf or a composite component
é Liabilities
Ý It makes it harder to restrict the type of components of a composite

Design Patterns In Java

The Composite Pattern Bob Tarr
5

The Composite Pattern

l Implementation Issues
é A composite object knows its contained components, that is, its children.
Should components maintain a reference to their parent component?
Ý Depends on application, but having these references supports the Chain of
Responsibility pattern
é Where should the child management methods (add(), remove(), getChild())
be declared?
Ý In the Component class: Gives transparency, since all components can be
treated the same. But it's not safe, since clients can try to do meaningless
things to leaf components at run-time.
Ý In the Composite class: Gives safety, since any attempt to perform a child
operation on a leaf component will be caught at compile-time. But we lose
transparency, since now leaf and composite components have different
interfaces.

Design Patterns In Java

The Composite Pattern Bob Tarr
6

3
 The Composite Pattern

l Transparent vs. Safe

Component

operation( ) children
add( )
remove( )
getChild( )

Leaf Composite

TRANSPARENT

Component children

operation( )

Composite

Leaf
add( )
remove( )
getChild(

SAFE

Design Patterns In Java

The Composite Pattern Bob Tarr
7

The Composite Pattern

l Implementation Issues
é Should Component maintain the list of components that will be used by a
composite object? That is, should this list be an instance variable of
Component rather than Composite?
Ý Better to keep this part of Composite and avoid wasting the space in every leaf
object
é Is child ordering important?
Ý Depends on application
é Who should delete components?
Ý Not a problem in Java! The garbage collector will come to the rescue!
é What's the best data structure to store components?
Ý Depends on application

Design Patterns In Java

The Composite Pattern Bob Tarr
8

4
 Composite Pattern Example 1

l Situation: A GUI system has window objects which can contain

various GUI components (widgets) such as, buttons and text
areas. A window can also contain widget container objects which
can hold other widgets.
l Solution 1: What if we designed all the widgets with different
interfaces for "updating" the screen? We would then have to
write a Window update() method as follows:
public class Window {

Button[] buttons;
Menu[] menus;
TextArea[] textAreas;
WidgetContainer[] containers;

Design Patterns In Java

The Composite Pattern Bob Tarr
9

Composite Pattern Example 1 (Continued)

public void update() {

if (buttons != null)
for (int k = 0; k < buttons.length; k++)
buttons[k].draw();
if (menus != null)
for (int k = 0; k < menus.length; k++)
menus[k].refresh();
// Other widgets handled similarly.
if (containers != null)
for (int k = 0; k < containers.length; k++ )
containers[k].updateWidgets();
}
...
}

l Well, that looks particularly bad. It violates the Open-Closed

Principle. If we want to add a new kind of widget, we have to
modify the update() method of Window to handle it.
Design Patterns In Java
The Composite Pattern Bob Tarr
10

5
 Composite Pattern Example 1 (Continued)

l Solution 2: We should always try to program to an interface,

right? So, let's make all widgets support the Widget interface,
either by being subclasses of a Widget class or implementing a
Java Widget interface. Now our update() method becomes:
public class Window {
Widget[] widgets;
WidgetContainer[] containers;
public void update() {
if (widgets != null)
for (int k = 0; k < widgets.length; k++)
widgets[k].update();
if (containers != null)
for (int k = 0; k < containers.length; k++ )
containers[k].updateWidgets();
}
}
Design Patterns In Java
The Composite Pattern Bob Tarr
11

Composite Pattern Example 1 (Continued)

l That looks better, but we are still distinguishing between widgets

and widget containers
l Solution 3: The Composite Pattern!

Component components

Button Menu WidgetContainer

Design Patterns In Java

The Composite Pattern Bob Tarr
12

6
 Composite Pattern Example 1 (Continued)

l Now the update method looks like:

public class Window {
Component[] components;

public void update() {

if (components != null)
for (int k = 0; k < components.length; k++)
components[k].update();
}

Design Patterns In Java

The Composite Pattern Bob Tarr
13

Composite Pattern Example 2 - The Java AWT

Design Patterns In Java

The Composite Pattern Bob Tarr
14

7
 Composite Pattern Example 3

l Situation: Many types of manufactured systems, such as computer

systems and stereo systems, are composed of individual
components and sub-systems that contain components. For
example, a computer system can have various chassis that contain
components (hard-drive chassis, power-supply chassis) and
busses that contain cards. The entire system is composed of
individual components (floppy drives, cd-rom drives), busses and
chassis.

Design Patterns In Java

The Composite Pattern Bob Tarr
15

Composite Pattern Example 3 (Continued)

l Solution: Use the Composite pattern!

Equipment equipment

FloppyDisk Card EquipmentComposite

Bus Chassis

Design Patterns In Java

The Composite Pattern Bob Tarr
16