A structural design pattern serves as a blueprint for how different classes and objects are combined to form larger structures.
Unlike creational patterns, which are mostly different ways to fulfill the same fundamental purpose, each structural pattern has a different purpose.
Question: What unifies structural patterns?
Answer: They all involve connections between objects.
In some sense, structural patterns are similar to the simpler concept of data structures.
However, structural design patterns also specify the methods that connect objects, not merely the references between them.
Furthermore, data structures are fairly static entities. They only describe how data is arranged in the structure. A structural design pattern also describes how data moves through the pattern.
Structural class patterns use inheritance to combine the interfaces or implementations of multiple classes. Structural class patterns are relatively rare.
Structural object patterns use object composition to combine the implementations of multiple objects. They can combine the interfaces of all the composed objects into one unified interface or they can provide a completely new interface.
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.
describe how objects can be composed into larger structures using object composition
, or the inclusion of objects within other objects.
For example, we will see that the
can be used to make one class interface match another to make programming easier.
We will also look at a number of other structural patterns where we combine objects to provide new functionality.
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 a pattern 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 Facade 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, the Decorator pattern
can be used to add responsibilities to objects dynamically.