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.

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 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 Façade pattern is used to make a single class represent an entire subsystem

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.