Structural Patterns  «Prev  Next»
Lesson 10

Structural Pattern Conclusion

Structural object patterns use composition to build larger structures from individual objects. Structural class patterns use inheritance to combine the interfaces or implementations of multiple classes. What are additional properties of Structural Design Patterns which enable software architects build systems?
Structural Design Patterns serve as the architectural underpinnings that allow complex systems to be constructed in an organized, maintainable, and efficient manner. Beyond merely using composition and inheritance as foundational mechanisms, these patterns offer nuanced capabilities that significantly benefit software architects in system building. The properties that render Structural Design Patterns invaluable for architectural endeavors include:


Structural Design Patterns, by their very nature, encourage modularity. They promote the division of a complex system into discrete, manageable components, thereby enhancing the system's maintainability and making it easier to understand, develop, and test individual parts in isolation.

Interface Segregation

Patterns like the Adapter or the Facade allow architects to create lightweight interfaces focused on client requirements. Such interface segregation simplifies client interactions with complex subsystems, fostering an architectural landscape where high cohesion and low coupling are achieved, ultimately augmenting system extensibility.

Code Reusability

One of the quintessential advantages of employing Structural Design Patterns is the elevation of code reusability. By abstracting common functionalities into shared components or interfaces, these patterns allow existing code to be reused across various parts of the system, reducing redundancy and the overall development time.

Dynamic Composition

Patterns like the Composite enable architects to assemble entities into tree structures that represent part-whole hierarchies. This permits the construction of complex objects dynamically, at runtime, offering the flexibility to compose systems in multiple ways depending on situational requirements.

Nested Functionality

Decorator Pattern, a stalwart in the Structural Design Pattern category, allows architects to attach additional responsibilities to objects without altering their code. This offers a flexible alternative to subclassing for extending functionality, thus enabling a more modular approach to feature augmentation.

Contract Standardization

Proxy and Adapter Patterns can serve to standardize the contracts between different parts of a system. They act as middlemen that facilitate, regulate, and translate interactions between disparate components, ensuring that integrity and contract compliance are upheld throughout the system.

Incremental Complexity Management

Structural Design Patterns enable systems to grow incrementally in complexity without a proportional increase in system entropy. For instance, the Bridge Pattern allows an abstraction and its implementation to evolve independently, thereby permitting the extension of complex systems in a controlled manner

Loose Coupling

These patterns inherently promote loose coupling between objects or classes. The introduction of abstraction layers ensures that the dependency between various system components is minimized, leading to a system architecture that is robust and less prone to breakage upon changes.

Resource Optimization

Through the efficient organization and division of responsibilities, Structural Design Patterns often lead to better resource utilization. They can reduce the need for redundant data storage or processing power, thus contributing to more efficient, faster, and less resource-intensive systems.

Abstraction and Real-world Mapping

Structural Design Patterns often serve to map real-world entities and their relationships into the software domain, which aids in creating more intuitive and understandable system architectures. This simplifies both the development and the subsequent maintenance phases, providing a semantic framework that is easier to reason about.
In summary, Structural Design Patterns offer a multifaceted toolkit for constructing complex systems. They provide essential mechanisms for promoting modularity, reusability, dynamic composition, and several other critical architectural virtues. Their judicious application is integral to crafting robust, scalable, and maintainable software architectures.
This module discussed structural patterns. Structural object patterns use composition to build larger structures from individual objects. Structural class patterns use inheritance to combine the interfaces or implementations of multiple classes. Used properly, structural patterns can increase the efficiency of your code, enhance its reusability and flexibility, more cleanly separate implementation from interface, and reduce complexity by providing cleaner, simpler interfaces to a system that are easier for client programmers to understand.

  1. The Adapter Design Pattern is a type of design pattern that is used for converting the interface of a class into an interface that its clients expect to see. This pattern allows incompatible interfaces to work together.
  2. The Bridge Design Pattern separates an abstract interface from its implementation so that both the interface and its implementation can change without any dependancy between each other.
  3. The Composite Design Pattern is used to compose objects so that they can be represented in part-whole hierarchies in tree-structures. This pattern allows clients to treat individual objects equally.
  4. The Decorator Design Pattern is used when additional functionality needs to be added to objects dynamically. This pattern provides an alternative to subclassing for extending an object's functionality.
  5. The Facade Design Pattern is used to provide a high-level interface that makes the subsystem easier to use. It helps create a unified interface to a set of interfaces in the subsystem.
  6. The Flyweight Design Pattern is used to share a large numbers of small objects efficiently
  7. The Proxy Design Pattern is used is used when it is required to use another object as a substitute to control access to this object.