Structural patterns include some quite sophisticated and powerful techniques. However, they are based on just a few basic techniques, primarily:

1. Delegation: The pattern is one in which a given object provides an interface to a set of operations. However, the actual work for those operations is performed by one or more other objects.
2. Object composition: Other objects are stored as pointers or references inside the object that provides the interface to clients. Object composition is a powerful yet often overlooked tool in the OOP programmer's toolbox. Structural patterns show you how to take advantage of it.

Structural patterns have many beneficial effects including:

1. Increased efficiency (Decorator, Flyweight, Proxy)
2. Enhanced reusability (Adapter, Bridge, Decorator)
3. Separating implementation from interface (Adapter, Bridge, Façade, Proxy)
4. Reducing complexity by providing cleaner, simpler interfaces to a system that are easier for client programmers to understand (Adapter, Bridge, Composite, Facade, Proxy)

In the context of design patterns, you will see classes that use other classes in their construction. When one class passes off a task to another class, that is delegation. It’s what makes composition so powerful. With inheritance, each child IS-A part of another class or classes. With composition, objects may USE-A different class or group of classes for a series of tasks. This does not mean that inheritance should not be used. In fact, most design patterns include inheritance and composition used together. Instead of using inheritance in a long series of child, grandchild, great-grandchild, a design pattern approach encourages using shallow inheritance and using the functionality of more than a single class.
This approach helps to avoid tight binding and crashes occurring when changes are made to designs where concrete classes have child classes.