Please enable JavaScript.

Coggle requires JavaScript to display documents.

Design Pattern (Intermediate Design Patterns (Iterator Pattern (Parts…

- - - - InterableProtocol: defines a type that can be iterated using a for in loop
      - A custom object is an object you want to make iterable
  - - - A copying protocol that declares copy methods
      - A prototype class that conforms to the copying protocol
  - - - Legacy object existed before the protocol was made and cannot be modified directly to conform to it
      - New protocol is the desired protocol for use
      - Adapter is created to conform to the protocol and passes calls onto the legacy object
      - Object using an adapter is the object that depends on the new protocol
    - - Classes, modules, functions can't be modified => you have to adapt instead
  - - - State protocol defines required methods and properties. Developers commonly substitute a base state class in place if a protocol so that they can define stored properties in the base
      - Concrete states conform to the state protocol or if a base class is used instead, they subclass the base
      - Context is the object that has a current state and whose behavior changes
    - - Example: A traffic light can be defined using a closed set of "traffic light states"
      - Use to create a system that has two or more states that is changes between during its lifetime
  - - - Factory: Creates objects
      - Products: are the objects that are created
    - - Separate out product creation logic, instead of having consumers create products directly
      - Useful when you have a group of several objects that implement the same protocol
      - Useful if you have a single product type but it requires dependencies or information to be provided to create it
  - - - Delegate protocol defines the methods a delegate may or should implement
      - Delegate(s) are objects that implement the delegate protocol
      - object needing a delegate: the object that has one or more delegates
      - Multicast delegate is a helper class that holds onto delegates and allows you to notify each delegate whenever a delegate-worthy event happens
  - - - Facade provides simple methods to interact with the system
      - Dependencies are objects owned by the facade. Each dependency performs a small part of a complex task
    - - You have a system made up of multiple components and want to provide a simple way for users to perform complex tasks
      - Example: A product ordering system
        
        Inventory in stock
        
        Shipping orders an others
        
        Customers and products
        
        You can provide a facade to expose common tasks such as placing and fulfilling a new order
- - - - A Leaf is a component of the tree that does not have child elements
      - A Composite is a container that can hold leaf objects ans composites
      - Component protocol ensures all constructs in the tree can be treated the same way
      - Both composites and leaf nodes derive from the component protocol
    - - If your app's class hierarchy forms a branching pattern. You can solve this problem with the composite pattern by treating branches and nodes the same by making them conform them to a protocol
  - - - Mediator the object that controls the communication of the colleagues. It implements the mediator protocol
      - Colleague protocol defines methods and properties that each colleague must implement
      - Mediator protocol defines methods and properties that the mediator must implement
      - Colleagues: the objects that want to communicate with each other, they implement the colleague protocol
      - Each colleague contains a reference to the mediator via the mediator protocol
    - - To separate interactions between colleagues into an object, the mediator
- - - - Memento
        
        Represent a stored state
      - CareTaker
        
        Request a save from the originator and receives a memento in response
        
        responsible for persisting the memento and later on providing the memento back to the originator to restore the originator's state
      - Originator
        
        Object to be saved or restored
    - - Exp: Save game system where the originator is the game state, the memento is saved data and the caretaker is the gaming system
      - Can persist an array of mementos, representing a stack of previous states, to implement features such as undo/redo statcks
      - Whenever you want to save and later restore an object's state
  - - - Observer is the object doing the observing
      - The subject is the object that's being observed
    - - You want to receive changes made on another object
  - - - Product: is the complex object to be created
      - Builder: accepts step-by-step inputs and handles the creation of the product
      - Director: accepts inputs and coordinated with the builder
    - - Use
        
        Work well when the product requires multiple inputs
        
        Use when you want to create a complex object using a series of steps
      - Example
        
        Implement a Hamburger builder
        
        The product could be a hamburger model, which has inputs such as meat, toppings ans sauces
        
        Director could be an employee object which know how to buil hamburgers
        
        The builder can thereby accept meat selection, toppings in any order and create a hamburger upon request
  - - - strategy protocol: defines methods that every strategy must implement
      - Strategies are objects that conform to the strategy protocol
      - Object using a strategy: often VC
    - - Have two or more different behaviors that are interchangeable
      - any object that implements the protocol can be used as a strategy at runtime
- - - - Strategy
      - Observer
      - Delegation
      - How objects communicate with each other
    - - Dingleton
      - Prototype
      - Builder
      - how to create or instantiate objects
    - - MVVM
      - Facade
      - MVC
      - How objects are composed and combined to form larger structures