Part 3: Structural Patterns

Structural patterns describe how classes and objects can be combined to form larger structures. The difference between class patterns and object patterns is that class patterns describe how inheritance can be used to provide more useful program interfaces. Object patterns, on the other hand, describe how objects can be composed into larger structures using object composition or the inclusion of objects within other objects.

For example, we’ll see that the Adapter pattern can be used to make one class interface match another to make programming easier. We’ll also look at a number of other structural patterns where we combine objects to provide new functionality. The Composite, for instance, is exactly that—a composition of objects, each of which may be either simple or itself a composite object. The Proxy pattern is frequently a simple object that takes the place of a more complex object that may be invoked later—for example, when the program runs in a network environment.

The Flyweight pattern is used for sharing objects, where each instance does not contain its own state but stores it externally. This allows efficient sharing of objects to save space when there are many instances but only a few different types.

The Façade pattern is used to make a single class represent an entire subsystem, and the Bridge pattern separates an object’s interface from its implementation so you can vary them separately. Finally, we’ll look at the Decorator pattern, which can be used to add responsibilities to objects dynamically.

You’ll see that there is some overlap among these patterns and even some overlap with the behavioral patterns in the next chapter. We’ll summarize these similarities after we describe the patterns.