Design & Architectural Patterns Overview

Patterns are reusable solutions to common problems in software design. They are templates for how to solve a problem that can be used in many different situations.

Table of Contents

Creational Patterns

Object creation mechanisms that increase flexibility and reuse of existing code.

  • Factory Method: Provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created.
  • Abstract Factory: Lets you produce families of related objects without specifying their concrete classes.
  • Builder: Lets you construct complex objects step by step.
  • Prototype: Lets you copy existing objects without making your code dependent on their classes.
  • Singleton: Lets you ensure that a class has only one instance, while providing a global access point to this instance.

Structural Patterns

How to assemble objects and classes into larger structures while keeping these structures flexible and efficient.

  • Adapter: Allows objects with incompatible interfaces to collaborate.
  • Bridge: Lets you split a large class or a set of closely related classes into two separate hierarchies—abstraction and implementation—which can be developed independently.
  • Composite: Lets you compose objects into tree structures and then work with these structures as if they were individual objects.
  • Decorator: Lets you attach new behaviors to objects by placing these objects inside special wrapper objects that contain the behaviors.
  • Facade: Provides a simplified interface to a library, a framework, or any other complex set of classes.
  • Flyweight: Lets you fit more objects into the available amount of RAM by sharing common parts of state between multiple objects instead of keeping all of the data in each object.
  • Proxy: Lets you provide a substitute or placeholder for another object.

Behavioral Patterns

Algorithms and the assignment of responsibilities between objects.

  • Chain of Responsibility: Lets you pass requests along a chain of handlers.
  • Command: Turns a request into a stand-alone object that contains all information about the request.
  • Interpreter: Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
  • Iterator: Lets you traverse elements of a collection without exposing its underlying representation.
  • Mediator: Lets you reduce chaotic dependencies between objects.
  • Memento: Lets you save and restore the previous state of an object without revealing the details of its implementation.
  • Observer: Lets you define a subscription mechanism to notify multiple objects about any events that happen to the object they’re observing.
  • State: Lets an object alter its behavior when its internal state changes.
  • Strategy: Lets you define a family of algorithms, put each of them into a separate class, and make their objects interchangeable.
  • Template Method: Defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure.
  • Visitor: Lets you separate algorithms from the objects on which they operate.

Architectural Patterns

High-level structure of applications.

UI / Presentation

  • MVC: Separates data (Model), UI (View), and logic (Controller).
  • MVP: View is passive; Presenter handles all UI logic.
  • MVVM: Two-way data binding between View and ViewModel.
  • VIPER: Extreme separation of concerns (View, Interactor, Presenter, Entity, Router).
  • Flux / Redux: Unidirectional data flow.
  • MVI: Model-View-Intent.

System / Enterprise