Design Patterns

Design Patterns

I want to learn some more patterns 🙂

This page is to keep track of the most common patterns.

See also https://en.wikipedia.org/wiki/Software_design_pattern#Classification_and_list

Classification and list

Design patterns were originally grouped into the categories: creational patterns, structural patterns, and behavioral patterns, and described using the concepts of delegation, aggregation, and consultation.

For further background on object-oriented design, see coupling and cohesion, inheritance, interface, and polymorphism. Another classification has also introduced the notion of architectural design pattern that may be applied at the architecture level of the software such as the Model–View–Controller pattern.

So you can divide the patterns into these categories:

  • Creational patterns
  • Structural patterns
  • Behavioral patterns
  • Concurrency patterns

Other resources:

https://en.wikipedia.org/wiki/Design_Patterns

Books

https://en.wikipedia.org/wiki/Code_Complete

 

Creational patterns

Five well-known design patterns that are parts of creational patterns are the

  • Abstract factory pattern, which provides an interface for creating related or dependent objects without specifying the objects’ concrete classes.[3]
  • Builder pattern, which separates the construction of a complex object from its representation so that the same construction process can create different representations.
  • Factory method pattern, which allows a class to defer instantiation to subclasses.[4]
  • Prototype pattern, which specifies the kind of object to create using a prototypical instance, and creates new objects by cloning this prototype.
  • Singleton pattern, which ensures that a class only has one instance, and provides a global point of access to it.[5]

 

Structural patterns

Examples of Structural Patterns include:

  • Adapter pattern: ‘adapts’ one interface for a class into one that a client expects
    • Adapter pipeline: Use multiple adapters for debugging purposes.[1]
    • Retrofit Interface Pattern:[2][3] An adapter used as a new interface for multiple classes at the same time.
  • Aggregate pattern: a version of the Composite pattern with methods for aggregation of children
  • Bridge pattern: decouple an abstraction from its implementation so that the two can vary independently
    • Tombstone: An intermediate “lookup” object contains the real location of an object.[4]
  • Composite pattern: a tree structure of objects where every object has the same interface
  • Decorator pattern: add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes
  • Extensibility pattern: a.k.a. Framework – hide complex code behind a simple interface
  • Facade pattern: create a simplified interface of an existing interface to ease usage for common tasks
  • Flyweight pattern: a large quantity of objects share a common properties object to save space
  • Marker pattern: an empty interface to associate metadata with a class.
  • Pipes and filters: a chain of processes where the output of each process is the input of the next
  • Opaque pointer: a pointer to an undeclared or private type, to hide implementation details
  • Proxy pattern: a class functioning as an interface to another thing

 

Behavioral patterns

Examples of this type of design pattern include:

Concurrency patterns

In software engineering, concurrency patterns are those types of design patterns that deal with the multi-threaded programming paradigm. Examples of this class of patterns include:

 

 

 

 

.

.

 

 

 

Advertisements