Please enable JavaScript.

Coggle requires JavaScript to display documents.

Design patterns - Coggle Diagram

- - - - is a reusable solution that can be applied to commonly occurring problems in software design-in
      - a solution to a common problem
  - - - result and trade-offs of applying the pattern
    - - describe when to apply the pattern
    - - describe the elements that make up the design, their relationships, responsibilities and collaborations
    - - descibe a design problem
        
        solution and consequence in word or two
- - - - with
        
        Visitor
        
        Iterator
  - - - to
        
        Abstract Factory
- - - - OBJECT PATTERN
        
        WHAT
        
        deal with object relationships, which can be changed at run-time and are more dynamic
      - CLASS PATTERN
        
        WHAT
        
        deal with relationships between classes and their subclasses
    - - specifies whether the pattern applies primarily to classes or to objects
  - - - Creational
        
        WHAT
        
        consern the process of object creation
        
        These patterns outline a number of ways in which objects could be created and their lifecycles managed
        
        ( type of scope )
        
        object
        
        ABSTRACT FACTORY ( KIT )
        
        what
        
        provides an interface for creating families of related or dependent objects without specifying their concrete classes
        
        SINGLETON
        
        intent
        
        Ensure a class has only one instance, and provide a global point of access to it
        
        1 more item...
        
        example
        
        global cache
        
        cache data
        
        PROTOTYPE
        
        BUILDER
        
        class
        
        Factory method or Virtual Constructor
        
        what
        
        defines one method, createThing for instance, which is overriden by subclasses who decide what to return
      - Behavioral
        
        WHAT
        
        characterize the ways in which classes or objects interact and distribute responsibility
        
        These patterns describe how objects interact with each other
        
        ( type of scope )
        
        object
        
        VISITOR
        
        COMMAND
        
        Strategy or Policy
        
        what
        
        enables you to select algorithms at runtime
        
        example
        
        validator
        
        when to used it
        
        When you have a part of your Class that's subject to change frequently or perhaps you have many related subclasses which only differ in behavior it's often a good time to consider using a Strategy pattern
        
        Iterator or Cursor #
        
        What
        
        Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation
        
        work with the individual elements
        
        STATE
        
        MEMENTO
        
        Observer or "custom events"
        
        what
        
        implements a single object which maintains a reference to a collection of objects and broadcasts notifications when a change of state occurse
        
        use
        
        widely used in client-side JS programing
        
        browser events or custom events
        
        1 more item...
        
        CHAIN OF RESPONSIBILITY
        
        BSERVER
        
        Mediator (Intermediary, Controller)
        
        problem :unamused:
        
        solution :smiley:
        
        intent :cloud:
        
        lets you reduce chaotic dependencies between objects. The pattern restricts direct communications between the objects and forces them to collaborate only via a mediator object
        
        structure :building_construction:
        
        applicability
        
        class
        
        TEMPLATE METHOD
        
        INTERPRETER
      - Structural
        
        WHAT
        
        assemble objects and classes into larger structures while keeping these structures flexible and efficient
        
        ( type of scope )
        
        class/object
        
        Adapter
        
        problem :unamused:
        
        solution :smiley:
        
        intent :cloud:
        
        that allows objects with incompatible(nespojivi) interfaces to collaborate.
        
        structure :building_construction:
        
        applicability
        
        object
        
        Wrapper
        
        Decorator
        
        applicability
        
        1 more item...
        
        problem :unamused:
        
        solution :smiley:
        
        intent :cloud:
        
        1 more item...
        
        structure :building_construction:
        
        example
        
        1 more item...
        
        Facede
        
        intent :cloud:
        
        provides the user with a simple interface, while hiding it's underlying complexity
        
        problem :unamused:
        
        solution :smiley:
        
        structure :building_construction:
        
        applicability
        
        keyword
        
        simple interface for complex library
        
        similar
        
        Mediator
        
        Composite (Object tree)
        
        problem :unamused:
        
        makes sense only when the core model of your app can be represented as a tree
        
        solution :smiley:
        
        intent :cloud:
        
        lets you compose objects into tree structures and then work with these structures as if they were individual objects
        
        structure :building_construction:
        
        applicability
        
        Bridge
        
        problem :unamused:
        
        solution :smiley:
        
        intent :cloud:
        
        structure :building_construction:
        
        applicability
        
        Flyweight (Cache)
        
        problem :unamused:
        
        solution :smiley:
        
        intent :cloud:
        
        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
        
        structure :building_construction:
        
        applicability
        
        Proxy
        
        problem :unamused:
        
        solution :smiley:
        
        intent :cloud:
        
        lets you provide a substitute or placeholder for another object. A proxy controls access to the original object, allowing you to perform something either before or after the request gets through to the original object
        
        structure :building_construction:
        
        applicability
    - - reflects what a pattern does