Lesson 1

This module explores structural patterns, patterns that use composition to merge objects and classes into larger structures. A good toolbox of structural patterns allows you to solve many thorny problems you are likely to encounter.
They show you how to glue different pieces of a system together in a flexible and extensible fashion. Structural patterns help you guarantee that when one of the parts changes, the entire structure does not need to change. They also show you how to recast pieces that do not fit (but that you need to use) into pieces that do fit.
In this module, you will learn:

1. How programmers use structural patterns
2. The characteristics of some commonly used structural patterns
3. When and when not to use the Flyweight pattern
4. How the Flyweight pattern can help with your course project

Structural patterns are design patterns that use composition to merge objects and classes into larger structures. These patterns focus on how objects and classes are composed to form more complex structures while maintaining flexibility and efficiency.
Key Features of Structural Patterns:

1. Composition over Inheritance – Structural patterns often favor composition to build relationships between objects rather than deep class hierarchies.
2. Scalability and Maintainability – They help create systems that are easier to extend and modify by defining well-structured object interactions.
3. Encapsulation of Relationships – They encapsulate how objects interact with each other, often hiding complex internal details.

Examples of Structural Patterns:

1. Adapter Pattern – Allows incompatible interfaces to work together by wrapping one class inside another.
2. Bridge Pattern – Separates an abstraction from its implementation, allowing both to evolve independently.
3. Composite Pattern – Organizes objects into tree structures to represent part-whole hierarchies.
4. Decorator Pattern – Dynamically adds new behavior to objects without modifying their structure.
5. Facade Pattern – Provides a simplified interface to a complex system.
6. Flyweight Pattern – Shares objects efficiently to minimize memory usage.
7. Proxy Pattern – Provides a placeholder for another object to control access to it.

Example of Composition in Structural Patterns:

• In the Composite pattern, an object can contain other objects, allowing individual objects and groups of objects to be treated uniformly.
• In the Decorator pattern, an object is wrapped dynamically with additional behavior, promoting composition over subclassing.

Structural Design Patterns serve as pivotal architectural paradigms that primarily focus on the composition of classes or objects to form more complex, integrated, and larger structural entities. Unlike Creational Patterns, which concern themselves with the efficient creation of objects, and Behavioral Patterns, which concentrate on object collaboration and responsibilities, Structural Patterns address the arrangement and assembly of multifaceted systems, ensuring the components interoperate seamlessly. Structural Patterns streamline the software architecture by providing high-level building blocks that foster scalability and sustainability. They promote the concept of object composition over inheritance, thereby ensuring that systems are easier to extend or modify. By isolating the intricacies of object collaboration and structure, these patterns create a layer of abstraction that simplifies client interaction with a set of individual objects acting as a unified whole.
A classic example is the "Composite Pattern," which composes objects into tree-like structures to represent part-whole hierarchies. This is notably useful when clients need to treat individual objects and compositions of objects uniformly. Another prevalent Structural Pattern is the "Adapter Pattern," which allows incompatible interfaces to collaborate. It essentially acts as a wrapper that bridges the gap between two disparate interfaces, making one compatible with the other without altering their existing code. The "Proxy Pattern" serves as another exemplar. It provides a placeholder or surrogate for another object to control access to it. This is particularly beneficial for implementing lazy initialization, access control, logging, and monitoring. Similarly, the "Decorator Pattern" dynamically adds new responsibilities to objects without altering their code. It is akin to wrapping a gift, where the primary object is wrapped with additional functionalities, altering its behaviors as needed.
Thus, in the panorama of software design, Structural Patterns are instrumental in creating versatile, maintainable, and scalable architectures. They embody the principle that "the whole is greater than the sum of its parts," guiding developers toward a modular design where components can be freely composed and interchanged, without disrupting the integrity and functionality of the larger system. These patterns are not just codified best practices but are essential strategies for crafting robust and adaptable software architectures.

As the future architects of software systems, it is crucial that we appreciate and understand the cornerstones of our craft. And one of the fundamental aspects that is instrumental to our growth and progress is the understanding of Structural Design Patterns. It is not just a tool for us, but a guiding philosophy that shapes our approach to building robust and effective systems.
Structural Design Patterns are not just about structuring classes and objects, but they serve as the bedrock upon which complex software applications are built. Their importance is so paramount that they form the second layer of the ‘Gang of Four’ design patterns, a collection of foundational techniques for software development. Patterns like

1. Adapter,
2. Composite,
3. Proxy,
4. Flyweight,
5. Facade,
6. Bridge, and
7. Decorator

have stood the test of time, proving their mettle across countless projects. When we talk about Structural Design Patterns, we talk about scalability, maintainability, and extensibility. They help us to identify a simple way to realize relationships among entities. They allow us to encapsulate complex functionalities into simplified interfaces, promote code reuse, and make it easier for us to add new features without causing disruptions. In a nutshell, they enable us to build systems that are easy to understand, extend, and maintain.
For example, consider the Adapter pattern. It serves as a bridge between two incompatible interfaces. How many times have we come across libraries that don't work well together? How many times have we felt the need to wrap an existing module to add some new behaviors? The Adapter pattern allows us to seamlessly integrate components, saving us countless hours of refactoring. Similarly, think about the Facade pattern. It provides a unified high-level interface to a set of interfaces in a subsystem, which makes the subsystem easier to use. We can encapsulate complex subsystems behind a simplified API, giving us more control over the system's intricacies. It’s like the proverbial tip of the iceberg, there’s a lot more beneath the surface than what meets the eye.
We must strive to learn and apply these patterns not because it's a trend, but because it's an industry standard. It's what distinguishes an exceptional software architect from an average one. It's the difference between building a system that merely works and one that thrives under the test of real-world challenges. Therefore, I implore you all to dive into Structural Design Patterns with an open mind. Let's demystify these patterns, understand their importance, and make them a part of our software development DNA. We are engineers, architects, builders of a new age. Let's make the most of these design patterns to become the best versions of ourselves and create systems that are not just efficient but are pieces of architectural brilliance.
Remember, the journey of a thousand miles begins with a single step. Let's take that step together towards understanding and mastering Structural Design Patterns. Because this is not just about writing code, it's about writing the future.

1. Adapter: Adapts one interface for a class into one that a client expects
2. Bridge: Decouple an abstraction from its implementation so that the two can vary independently
3. Composite: A tree structure of objects where every object has the same interface
4. Decorator : Add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes
5. Facade: Create a simplified interface of an existing interface to ease usage for common tasks
6. Flyweight: A high quantity of objects share a common properties object to save space
7. Proxy: A class functioning as an interface to another thing