Patterns

Abstract Factory

interface for creating families of related objects without defining concrete classes

Builder

separates the construction of a object from its reprenstation, allowing variation

Factory Method

defines a interface for creating a object, but let subclasses instantate.

Prototype

Create new objects by duplicating existing ones. Instead of creating objects from scratch, make copies of an existing object.

Singleton

ensures a class has only one instance and provides a global access point to it.

Chain of Responsibility

passes a request along a chain of handlers, giving each a chance to process it

Command

wraps a request as a object, separating invoker and receiver, allowing for queuing, logging, undo

Interpreter

breaks down language/expression rules into objects that represent/handle each rule

Iterator

provides a way to access elements of collection without exposing its underlying structure.

Mediator

defines a central object that handles communication between other objects, avoiding direct connections

Memento

capture and store a objects state so that it can be used later w/o exposing its underlying structure

Observer

defines a one-to-many relationship where when one object changes state, all its dependents are notified.

State

allows object to change in behavior when its internal state changes, appearing as if it has changed its class

Strategy

Organizes a family of algorithms into separate classes, allowing a object to select behavior at runtime.

Template Method

defines skeleton of algorithm in a method, allowing subclasses to customize steps w/o changing the process

Visitor

separates objects and their operations, allowing for new operations to be added without modifying the existing code.

Adapter

converts interface of class into one another expects by wrapping the existing class with a new interface

Bridge

separates abstraction and implementation into their own hierarchies allowing them to work independently

Composite

organize objects into tree structure, lets you treat single objects and groups of objects the same

Decorator

wrap object to add new behavior at runtime without changing its structure

Facade

provides a single interface for a complex subsystem, hiding internal details

Flyweight

shares a common state between multiple objects, efficantly layering intrinsic(shared) and extrinsic(unique) data

Proxy

provide a placeholder for another object to control access to it

What are all the Creational patterns: FAB PS

1.Factory Method, Abstract Factory, Builder 2.Prototype, Singleton

What are all the Structural Patterns: CDP BAFF

1.Composite, Decorator, Proxy
2.Bridge, Adapter, Facade, Flyweight

What are the Behavioral Patterns: TV COMIC MISS

1.Template Method, Visitor
2.Chain of Responsibility, Observer ,Mediator, Iterator, Command

3.Memento,Inteprerter, Strategy, State