Design Patterns

OO Principles:
- Encapsulate what varies
- Favor composition over inheritance
- Program to interface, not implementation
- Strive for loosely coupled designs between objects that interact
- Classes should be open for extension, but closed for modification
- Depend on abstractions. Do not depend on concrete classes
- Only talk to your friends
- Don't call us, we'll call you
- A class should have only one reason to change

OO Patterns:
- Strategy: defines a family of algorithm, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it
- Observer: defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically
- Decorator: Attach additional responsibilities to an object dynamically, provide a flexible alternative to subclassing for extending functionality
- Factory: Define an interface for creating an object but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to the subclasses
- Abstract factory: Provide an interface for creating families of related or dependent objects without specifying their concrete classes
- Singleton: Ensure a class only has one instance and provide a global point to access to it
- Command: Encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests and support undoable operations
- Adapter: Converts the interface of a class into another interface clients expect. Lets classes work together that couldn't otherwise because of incompatible interfaces
- Facade: Provides a unified interface to a set of interfaces in a subsystems. Facade defines a higher-level interface that makes the subsystem easier to use
- Template: Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure
- Iterator: Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation
- Composite: Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly
- State: Allow an object to alter ít behavior when ít internal state changes. The object will appear to change íts class
- Compound (MVC): combines two or more patterns into a solution that solves a recurring or general problem
- Bridge
- Builder
- Chain of Responsibility
- Flyweight
- Interpreter
- Mediator
- Memento
- Prototype
- Visitor