Skip to content

Latest commit

 

History

History
33 lines (20 loc) · 2.89 KB

patterns.md

File metadata and controls

33 lines (20 loc) · 2.89 KB
  • Created using ChatGPT

Design patterns

Design patterns can be classified into three main categories: creational patterns, structural patterns, and behavioral patterns. Each category serves a different purpose in software design. Let's explore the differences between them:

Creational Patterns:

Creational patterns focus on object creation mechanisms, providing flexible ways to create objects while hiding the creation logic. They abstract the instantiation process and help make the system independent of how objects are created, composed, and represented. Some examples of creational patterns are:

  • Singleton: Ensures that only one instance of a class exists throughout the application.
  • Factory Method: Defines an interface for creating objects, but allows subclasses to decide which class to instantiate.
  • Abstract Factory: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Structural Patterns:

Structural patterns deal with object composition to form larger structures and provide solutions to organize objects and classes. They focus on class and object composition to create larger structures, while maintaining flexibility and efficiency. Some examples of structural patterns are:

  • Adapter: Allows objects with incompatible interfaces to work together by converting one interface into another.
  • Decorator: Dynamically adds responsibilities to an object by wrapping it with one or more decorator objects.
  • Composite: Composes objects into tree structures to represent part-whole hierarchies, allowing clients to treat individual objects and compositions uniformly.

Behavioral Patterns:

Behavioral patterns are concerned with communication between objects and how they interact and distribute responsibilities. They capture communication patterns between objects and help in implementing complex control flows and algorithms. Some examples of behavioral patterns are:

  • Observer: Defines a one-to-many dependency between objects, so that when one object changes state, all its dependents are notified and updated automatically.
  • Strategy: Defines a family of interchangeable algorithms and encapsulates each one, allowing them to be used interchangeably within a context.
  • Command: Encapsulates a request as an object, allowing parameterization of clients with different requests, queue or log requests, and support undoable operations.

These are just a few examples, and there are many more design patterns available. Some other types of patterns include architectural patterns (e.g., Model-View-Controller), concurrency patterns (e.g., Active Object), and enterprise patterns (e.g., Data Access Object).

Each pattern type addresses different aspects of software design and solves specific problems. By understanding and applying these patterns, you can improve the structure, flexibility, and maintainability of your software systems.