Uncategorised

List of Popular Design Pattern

September 24, 2023 Leave a Comment

A design pattern is a general reusable solution to a commonly occurring problem in software design. It is not a finished design that can be transformed directly into source or machine code. Rather, it is a description or template for how to solve a problem that can be used in many different situations.

Design patterns are often used to solve problems related to object-oriented design, but they can also be used to solve problems in other areas of software development, such as functional programming and distributed systems.

There are many different design patterns, but some of the most common ones include:

  • Singleton: This pattern ensures that there is only one instance of a class in existence.
  • Factory: This pattern creates objects without exposing the underlying creation logic to the client code.
  • Builder: This pattern separates the construction of a complex object from its representation.
  • Observer: This pattern allows objects to be notified of changes to other objects.
  • Adapter: This pattern allows objects with incompatible interfaces to work together.
  • Decorator: This pattern allows objects to be dynamically extended with new functionality.

Design patterns are reusable solutions to common problems encountered in software design and development. They provide proven, structured approaches to solving specific design challenges. Here’s a list of some commonly used design patterns categorized into three main groups: creational, structural, and behavioral.

Creational Design Patterns:

  1. Singleton Pattern: Ensures a class has only one instance and provides a global point of access to it.
  2. Factory Method Pattern: Defines an interface for creating an object but lets subclasses alter the type of objects that will be created.
  3. Abstract Factory Pattern: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
  4. Builder Pattern: Separates the construction of a complex object from its representation, allowing the same construction process to create different representations.
  5. Prototype Pattern: Creates new objects by copying an existing object, known as the prototype.

Structural Design Patterns:

  1. Adapter Pattern: Allows the interface of an existing class to be used as another interface.
  2. Bridge Pattern: Separates an object’s abstraction from its implementation, allowing them to vary independently.
  3. Composite Pattern: Composes objects into tree structures to represent part-whole hierarchies.
  4. Decorator Pattern: Attaches additional responsibilities to an object dynamically, providing a flexible alternative to subclassing.
  5. Facade Pattern: Provides a simplified interface to a set of interfaces in a subsystem, making it easier to use.
  6. Flyweight Pattern: Reduces memory usage or computational expenses by sharing as much as possible with other related objects.
  7. Proxy Pattern: Provides a surrogate or placeholder for another object to control access to it.

Behavioral Design Patterns:

  1. Chain of Responsibility Pattern: Passes a request along a chain of handlers. Each handler decides whether to process the request or pass it to the next handler in the chain.
  2. Command Pattern: Encapsulates a request as an object, allowing for parameterization of clients with queuing, requests, and operations.
  3. Interpreter Pattern: Defines a grammar for interpreting a language and provides an interpreter to interpret sentences in the language.
  4. Iterator Pattern: Provides a way to access elements of an aggregate object sequentially without exposing its underlying representation.
  5. Mediator Pattern: Defines an object that centralizes communication between objects in a system, promoting loose coupling.
  6. Memento Pattern: Captures an object’s internal state so that it can be restored to this state later.
  7. Observer Pattern: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
  8. State Pattern: Allows an object to alter its behavior when its internal state changes. The object will appear to change its class.
  9. Strategy Pattern: Defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the algorithm to vary independently from the context that uses it.
  10. Template Method Pattern: Defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure.
  11. Visitor Pattern: Represents an operation to be performed on elements of an object structure. It lets you define a new operation without changing the classes of the elements on which it operates.
Rajesh Kumar
Follow me
Latest posts by Rajesh Kumar (see all)
Subscribe
Notify of
guest
0 Comments
Inline Feedbacks
View all comments
0
Would love your thoughts, please comment.x
()
x