Skip to content

README.md

Latest commit

 

History

History
31 lines (25 loc) · 2.42 KB

README.md

File metadata and controls

31 lines (25 loc) · 2.42 KB
Raw

Structural Design Patterns

Structural design patterns are a category of design patterns focused on how objects and classes are composed to form larger structures. These patterns help ensure that if one part of a system changes, the entire system doesn't need to be modified. They aim to make the components of a system work together more effectively and efficiently. Here are the key concepts common to structural design patterns:

Key Concepts of Structural Design Patterns

  1. Composition over Inheritance:

    • Purpose: Encourages the use of object composition rather than inheritance to achieve flexibility and reuse.
    • Benefit: Promotes a design where objects are composed of other objects, which allows for more dynamic and flexible system structures compared to rigid inheritance hierarchies.

  2. Interfaces and Abstraction:

    • Purpose: Provides a way to define and use interfaces and abstract classes to achieve a level of abstraction and decoupling.
    • Benefit: Allows different parts of a system to interact through common interfaces, which enhances modularity and reduces dependencies.

  3. Decoupling:

    • Purpose: Reduces the dependency between components, making them more independent and interchangeable.
    • Benefit: Enhances system flexibility and maintainability by allowing components to be modified or replaced without affecting other parts of the system.

  4. Flexibility:

    • Purpose: Provides mechanisms to change the behavior or structure of a system at runtime or compile-time.
    • Benefit: Allows systems to adapt to new requirements or changes in requirements without significant changes to the existing code.

  5. Reusability:

    • Purpose: Enables the reuse of existing components and designs in different contexts or applications.
    • Benefit: Reduces redundancy and development time by leveraging existing solutions for new problems.

When to Use Structural Patterns

  • When you need to compose objects into larger structures without creating tight coupling.
  • When you want to add or extend the functionality of objects without modifying their structure.
  • When you need to simplify complex or cumbersome interfaces for easier use.
  • When your system involves complex class hierarchies and you want to manage them more efficiently.
  • When you want to reuse code and functionality in a flexible, maintainable way.
  • When you need to support multiple implementations of an interface and keep them interchangeable.