Design Pattern

1. Separate what changes from what stays the same
2. programming to an interface, not an implementation
3. favor composition over inheritance
4. stive for loosely coupled designs between Object that interact.
5. class should be open for extension, but close for modification.
6. Principle of least knowledge-talk only to your immediate firends.
7. Don't call us, we'll call you!
8. A class should have only one reason to change.

The Strategy pattern :
defines a family of algorithms, encapsulates each one, and make them interchangeable.
Strategy lets thes algorithm vary independently from clents that use it.
The Observer Pattern :
define a one-to-many dependency between objects
so that when one object changes state, all of it's dependents are notified and updated automatically

The Decorator Pattern :
attaches additional reponsibilities to an object dynamically.
Decorator privide a fiexible alternative to subclassing for extending functionality.

The Factory Method pattern :
define an interface for creating an object, but let subclasses decide which class to instantiate.
Factory Method lets a class defer instantiation to subclass.

The Abstract Factory :
provide a interface for creating families of related or dependent objects, without specifying their concrete classes.
The Singleton Pattern :
ensures a class can have only one instance,and have global point of access of it.

The Command Pattern :
encapsulate a request as a object,thereby let you to parameterize other objects with different requests,
queue or log request,and support undo operation.
The Adapter Pattern :
converts the interface of a class into another interface the clients expect.
Adapter lets classes work tegother that couldn't otherwise because of incompatible interface.
The Facade Pattern :
provide a unified interface to a set of interfaces in a subsystem.
Facade defines a high-level interface that make the subsystem easy to use.
The Template Method Pattern :
define a skeleton of a algorithm in a method, deferring some step to subclass.
Template Method lets subclass redine certain steps of an algorithm without changing the agorithem structure.
The Iterator Pattern :
provides a way to access the elements of an aggregate object sequentially exposing the underlying represetation.
The Composite Pattern :
allow you to composite objects into tree structures to represent part-whole hierarchies.
Composite lets clients treat individual objects and compositions of object uniformly.
The State Pattern :
allows an object to alter its behavior when its internal state changes.
The object will appear to change its class.