Design pattern overview

Overview of use-full design patterns:

Facade pattern

  • A simple class is converted to a advance class
  • The facade class serves as the class between the simple and the advance (Wrapper)

Adapter pattern:

  • An advance class is adapted to a simple class
  • The adapter class serves as the class between the advance and the simple (Wrapper)

Strategy pattern:

  • Delegates functionality through a common interface, alternative to the decorator class
  • The strategy class serve as the delegator to concrete strategy classes
  • Example of strategy class is a string work, string-check or a string-sort class(look these up)
  • Often utilizes polymorphism interfaces abstract and concrete classes and in heritage and composition.
  • Main purpose is to add function interchangeability to classes. You can also add functions to classes at runtime as long as the interface of the function is the same
  • Example: assertIsEmailFormat(email).assertIsNotDisposableEmailService(email).isUnique(email)

Factory pattern:

  • A builder class that builds classes upon requests
  • Example: makeSimpleButton(view).roundifyButton(view).addShadow(view).addTapCallBack(view, onTap)

Template pattern:

  • A delegation class that utilizes an abstract class to control the order that functions in sub classes are run
  • The class can utilize a hock function to disrupting the main algorithm flow. The order stays the same but functions can be omitted or behaviour changed
  • Depends on inheritance

Memento pattern

  • Saves and restores class states, can be used as undo redo and history functionality
  • Becomes Truly useful when used with a dynamic flash_proxy class

Iteration pattern

Iterates over a list of items great way to delegate functionality to other classes

  • Usually implements hasNext next and resets
  • The iterator class restates inside a collection class that usually. Return an itereator or reverse-iterator class based on passed argument

Proxy pattern

  • Is used to stand in for other objects such as files on remote servers
  • Often a try catch function is involved . XML and constants as stand INS is a perfect example

Command pattern

  • Encapsulated functions and invokes them in a sequence.
  • Often used to add undo and redo. Functionality

Composite pattern


Mediator pattern

  • Works almost like a one level down singleton class
  • A reference of the mediator class is passed down to sub classes an the sub classes then usually calls the mediators handle function with a state name as string. Then the handle function parses through a list of if else function and delegates functionality to the current state with a go function
  • Add example: find on google: swift mediator pattern example
  • With the mediator pattern, communication between objects is encapsulated within a mediator object. Objects no longer communicate directly with each other, but instead communicate through the mediator. This reduces the dependencies between communicating objects, thereby reducing coupling

Bridge pattern

  • Two abstract classes that communicates then use concrete classes to customise the communication.
  • Subclass with custom functionality. then call the common protocol
  • Great example:

Builder pattern

  • Creates a class and passes an iteratable array of function calls
  • The builder pattern is veery useful when you need to configure the order the functions are called in the created class

Decorator pattern

  • You decorate a class through composition rather than in-heritage.
  • The decorator has the same interface as the class it decorates and usually also employ the use of a common abstract decorator class.
  • One of the key benefits of using the decorator class is that you can change behaviour at runtime often without changing the class its decorating
  • basically every decorator class holds a ref to the inserted instance. Think russian doll

Proxy pattern

  • Similar to facade and adapter but have the same interface As the class it stands in for.
  • Usually Delegates local info if remote info is not available.

Observer pattern

  • Notification center etc

Visitor pattern:

  • Visitor is a behavioural design pattern that allows adding new behaviors to existing class hierarchy without altering any existing code.

Flyweight pattern:

  • to come

Design pattern Overview


  • Abstract Factory
  • Builder how a composite object gets created
  • Factory Method subclass of object that is instantiated
  • Prototype class of object that is instantiated
  • Singleton the sole instance of a class


  • Adapter interface to an object
  • Bridge implementation of an object
  • Composite structure and composition of an object
  • Decorator responsibilities of an object without subclassing
  • Facade interface to a subsystem
  • Flyweight storage costs of objects
  • Proxy how an object is accessed; its location


  • Chain of Responsibility object that can fulfill a request
  • Command when and how a request is fulfilled
  • Interpreter grammar and interpretation of a language
  • Iterator how an aggregate’s elements are accessed, traversed
  • Mediator how and which objects interact with each other
  • Memento what private information is stored outside an object, and when
  • Observer number of objects that depend on another object; how the dependent objects stay up to date
  • State states of an object
  • Strategy an algorithm
  • Template Method steps of an algorithm
  • Visitor operations that can be applied to object(s) without changing their class(es)