Structural Design Patterns focus on organizing classes and objects to build larger, efficient, and maintainable software structures. They simplify relationships, support code reuse, and help create scalable architectures.
- This pattern is particularly useful for making independently developed class libraries work together.
- Structural Design Patterns describe ways to compose objects to realize new functionality.
- The added flexibility of object composition comes from the ability to change the composition at run-time, which is impossible with static class composition.
Example: A drawing editor that lets users draw and arrange graphical elements (lines, polygons, text, etc.) into pictures and diagrams. The drawing editor's key abstraction is the graphical object, which has an editable shape and can draw itself.
Types of Structural Design Patterns
There are mainly 7 types of Structural design patterns
1. Adapter Design Pattern
Adapter or Adapter Design Pattern also knows as wrapper. It converts the interface of a class into another interface which clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
Uses
Adapter pattern is used to make an existing class compatible with a new interface without changing its source code.
- You want to use an existing class, and its interface does not match the one you need.
- You want to create a reusable class that cooperates with unrelated or unforeseen classes, that is, classes that don't necessarily have compatible interfaces.
- (object adapter only) you need to use several existing subclasses, but it's unpractical to adapt their interface by subclassing every one. An object adapter can adapt the interface of its parent class.
2. Bridge Design Pattern
By separating an object's implementation (how it does something) from its abstraction (what it does), the Bridge Design Pattern enables the two to develop separately.
Imagine you have different types of devices (like TVs and Radios) and different ways to control them (like Remote and Voice Control). Instead of tightly coupling each device with each control type, the Bridge pattern lets you connect them loosely.
Uses
Bridge pattern is used to separate an abstraction from its implementation so that both can vary independently.
- You want to avoid a permanent binding between an abstraction and its implementation. This might be the case, for example, when the implementation must be selected or switched at run-time.
- Changes in the implementation of an abstraction should have no impact on clients; that is, their code should not have to be recompiled.
- You want to hide the implementation of an abstraction completely from clients.
3. Composite Design Pattern
Composite Design Pattern composes objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
Uses
Composite pattern is used to treat individual objects and compositions of objects uniformly in a part-whole hierarchy.
- We want to represent part-whole hierarchies of objects.
- Wewant 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.
4. Decorator Design Pattern
The Decorator Design Pattern allows adding new features to an object dynamically without changing its structure. Instead of creating multiple variations, you wrap the original object with additional functionalities.
Uses
To add responsibilities to individual objects dynamically and transparently, that is, without affecting other objects.
- For responsibilities that can be withdrawn.
- When extension by subclassing is impractical. Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination.
5. Facade Design Pattern
Facade Design Pattern provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
Uses
Facade pattern is used to provide a unified and simplified interface to a set of interfaces in a subsystem.
- We want to provide a simple interface to a complex subsystem. Subsystems often get more complex as they evolve. This makes the subsystem more reusable and easier to customize, but it also becomes harder to use for clients that don't need to customize it.
- There are many dependencies between clients and the implementation classes of an abstraction. Introduce a facade to decouple the subsystem from clients and other subsystems.
- We want to layer your subsystems. Use a facade to define an entry point to each subsystem level. If subsystems are dependent, then you can simplify the dependencies between them by making them communicate with each other through their facades.
6. Flyweight Design Pattern
The Flyweight Design Pattern reduces memory usage by sharing common data across multiple objects instead of creating duplicates. It separates shared properties from unique ones to optimize resource usage.
Uses
The Flyweight pattern's effectiveness depends heavily on how and where it's used. Apply the Flyweight pattern when all of the following are applicable:
- An application uses a large number of objects.
- Storage costs are high because of the sheer quantity of objects.
- Many groups of objects may be replaced by relatively few shared objects once extrinsic state is removed.
- The application doesn't depend on object identity.
7. Proxy Design Pattern
The Proxy Design Pattern provides a surrogate or placeholder object that controls access to another object, allowing additional operations like access control, lazy loading, or logging without modifying the original object.
Uses
Proxy method is applicable whenever there is a need for a more versatile or sophisticated reference to an object than a simple pointer. Here are several common situations in which the Proxy pattern is applicable:
- A remote proxy provides a local representative for an object in a different address space.
- A virtual proxy creates expensive objects on demand.
- A protection proxy controls access to the original object. Protection proxies are useful when objects should have different access rights
- A smart reference is a replacement for a bare pointer that performs additional actions when an object is accessed.
Importance
Structural patterns provide several key benefits:
- Simplify Code: Structural patterns help organize and simplify code by connecting objects and classes in a clear way, making complex relationships easier to understand and manage.
- Reduce Duplicate Code: By reusing existing structures, structural patterns avoid duplicate code, which makes your program more efficient and less prone to errors.
- Enhance Flexibility: These patterns allow you to add or change features without altering existing code too much, making the program easier to extend or modify.
- Improve Readability: They provide a clear structure that organizes classes and objects, making it easier for others to understand and maintain the code.
- Optimize Resource Use: Structural patterns like Flyweight help reduce memory usage and improve performance by sharing common data among objects instead of duplicating it.
Challenges
Using structural patterns also comes with some challenges:
- Increased Complexity: Structural patterns like Decorator or Proxy can add layers to the code, making it harder to read and follow. If too many patterns are used, the code can become overly complex.
- Performance Issues: Some patterns, such as Flyweight, may need extra processing to manage shared objects. This can lead to slower performance if not used carefully.
- Overhead in Maintenance: As structural patterns add more classes and interfaces, it can be harder to maintain or update the code. New developers may need more time to understand how everything fits together.
- Risk of Overengineering: It’s easy to overuse patterns, which leads to unnecessary abstraction. Sometimes, simpler code without patterns is more effective and easier to work with.
- Difficulty in Debugging: With extra layers, tracing bugs can become challenging since the problem might be hidden deep within the pattern structure.