https://refactoring.guru/design-patterns/catalog

[announceme] Hey, I have just reduced the price for all products.
Let's prepare our programming skills for the post-COVID era. Check it
out >> [announceme]
   

The Catalog of Design Patterns

Creational patterns

These patterns provide various object creation mechanisms, which
increase flexibility and reuse of existing code.

Factory Method Factory Method Abstract Factory Abstract Factory 
Builder Builder Prototype Prototype Singleton Singleton

Structural patterns

These patterns explain how to assemble objects and classes into
larger structures while keeping these structures flexible and
efficient.

Adapter Adapter Bridge Bridge Composite Composite Decorator Decorator
Facade Facade Flyweight Flyweight Proxy Proxy

Behavioral patterns

These patterns are concerned with algorithms and the assignment of
responsibilities between objects.

Chain of Responsibility Chain of Responsibility Command Command 
Iterator Iterator Mediator Mediator Memento Memento Observer Observer
State State Strategy Strategy Template Method Template Method Visitor
Visitor
 Refactoring.Guru
Facebook
Twitter

  * Language
    English Espanol Francais Polski Portugues Brasileiro Russkii
    Ukrayins'ka Zhong Wen 
  * Contact us
  * Log in

HELP UKRAINE STOP RUSSIA
 
EnglishEnglish EspanolEspanol FrancaisFrancais PolskiPolski Portugues
BrasileiroPortugues-Br RusskiiRusskii Ukrayins'kaUkrayins'ka Zhong Wen Zhong Wen 
Refactoring.Guru
HELP UKRAINE
STOP RUSSIA

  * Premium Content
      + Design Patterns eBook
      + Refactoring Course
  * Refactoring
      + What is Refactoring
          o Clean code
          o Technical debt
          o When to refactor
          o How to refactor
      + Catalog
      + Code Smells
          o Bloaters
              # Long Method
              # Large Class
              # Primitive Obsession
              # Long Parameter List
              # Data Clumps
          o Object-Orientation Abusers
              # Switch Statements
              # Temporary Field
              # Refused Bequest
              # Alternative Classes with Different Interfaces
          o Change Preventers
              # Divergent Change
              # Shotgun Surgery
              # Parallel Inheritance Hierarchies
          o Dispensables
              # Comments
              # Duplicate Code
              # Lazy Class
              # Data Class
              # Dead Code
              # Speculative Generality
          o Couplers
              # Feature Envy
              # Inappropriate Intimacy
              # Message Chains
              # Middle Man
          o Other Smells
              # Incomplete Library Class
      + Refactorings
          o Composing Methods
              # Extract Method
              # Inline Method
              # Extract Variable
              # Inline Temp
              # Replace Temp with Query
              # Split Temporary Variable
              # Remove Assignments to Parameters
              # Replace Method with Method Object
              # Substitute Algorithm
          o Moving Features between Objects
              # Move Method
              # Move Field
              # Extract Class
              # Inline Class
              # Hide Delegate
              # Remove Middle Man
              # Introduce Foreign Method
              # Introduce Local Extension
          o Organizing Data
              # Self Encapsulate Field
              # Replace Data Value with Object
              # Change Value to Reference
              # Change Reference to Value
              # Replace Array with Object
              # Duplicate Observed Data
              # Change Unidirectional Association to Bidirectional
              # Change Bidirectional Association to Unidirectional
              # Replace Magic Number with Symbolic Constant
              # Encapsulate Field
              # Encapsulate Collection
              # Replace Type Code with Class
              # Replace Type Code with Subclasses
              # Replace Type Code with State/Strategy
              # Replace Subclass with Fields
          o Simplifying Conditional Expressions
              # Decompose Conditional
              # Consolidate Conditional Expression
              # Consolidate Duplicate Conditional Fragments
              # Remove Control Flag
              # Replace Nested Conditional with Guard Clauses
              # Replace Conditional with Polymorphism
              # Introduce Null Object
              # Introduce Assertion
          o Simplifying Method Calls
              # Rename Method
              # Add Parameter
              # Remove Parameter
              # Separate Query from Modifier
              # Parameterize Method
              # Replace Parameter with Explicit Methods
              # Preserve Whole Object
              # Replace Parameter with Method Call
              # Introduce Parameter Object
              # Remove Setting Method
              # Hide Method
              # Replace Constructor with Factory Method
              # Replace Error Code with Exception
              # Replace Exception with Test
          o Dealing with Generalization
              # Pull Up Field
              # Pull Up Method
              # Pull Up Constructor Body
              # Push Down Method
              # Push Down Field
              # Extract Subclass
              # Extract Superclass
              # Extract Interface
              # Collapse Hierarchy
              # Form Template Method
              # Replace Inheritance with Delegation
              # Replace Delegation with Inheritance
  * Design Patterns
      + What is a Pattern
          o What's a design pattern?
          o History of patterns
          o Why should I learn patterns?
          o Criticism of patterns
          o Classification of patterns
      + Catalog
      + Creational Patterns
          o Factory Method
          o Abstract Factory
          o Builder
          o Prototype
          o Singleton
      + Structural Patterns
          o Adapter
          o Bridge
          o Composite
          o Decorator
          o Facade
          o Flyweight
          o Proxy
      + Behavioral Patterns
          o Chain of Responsibility
          o Command
          o Iterator
          o Mediator
          o Memento
          o Observer
          o State
          o Strategy
          o Template Method
          o Visitor
      + Code Examples
          o C#
          o C++
          o Go
          o Java
          o PHP
          o Python
          o Ruby
          o Swift
          o TypeScript

Log in Contact us

  * Home
  * Refactoring
  * Design Patterns
  * Premium Content
  * Forum
  * Contact us

  *  
  *  
  *  

2014-2022 Refactoring.Guru. All rights reserved.
Organization address Khmelnitske shosse 19 / 27, Kamianets-Podilskyi,
Ukraine, 32305
Email: support@refactoring.guru
Illustrations by Dmitry Zhart

  * Terms & Conditions
  * Privacy Policy
  * Content Usage Policy