Design

Design Patterns give you a shared vocabulary with other developers. Once you’ve got the vocabulary you can more easily 
communicate with other developers and inspire those who don’t know patterns to start learning them. 
It also elevates your thinking about architectures by letting you think at the pattern level, not the nitty gritty 
object level.

Patterns, like all forms of complexity, should be avoided until they are absolutely necessary.

GOF

-------------------------------------------------------------------------------------------------

1 Favour composition over inheritance

2 Encapsulate what varies

3 Program to interfaces, not implementation

• Strategy Pattern

-------------------------------------------------------------------------------------------------

4 Loosely coupled principle allows us to build flexible OO systems that can handle change because they minimize the interdependency between objects.

• Observer Pattern

-------------------------------------------------------------------------------------------------

5 The Open-Closed Principle says Classes should be open for extension, but closed for modification.

• Decorator Pattern

-------------------------------------------------------------------------------------------------

6 Dependency inversion principle says depend upon abstractions not on concrete classes i.e: reducing dependencies to concrete classes in our code is a “good thing

• Simple Factory Pattern

• Factory method pattern

• Abstract Factory method pattern

-------------------------------------------------------------------------------------------------

• Singleton Pattern

-------------------------------------------------------------------------------------------------

• Command Pattern

-------------------------------------------------------------------------------------------------

• Adapter Pattern

-------------------------------------------------------------------------------------------------

6 The principle of least knowledge says that talk to your immediate friends

• Facade Pattern

-------------------------------------------------------------------------------------------------

7 The hollywood principle states, don't calls us, we'll call you

• Template pattern

-------------------------------------------------------------------------------------------------

8 Single responsibilty principle asks a class to have only one reason to change

• Iterator pattern

• Composite pattern

-------------------------------------------------------------------------------------------------

• State pattern

-------------------------------------------------------------------------------------------------

• Proxy pattern

-------------------------------------------------------------------------------------------------

• Compound patterns

-------------------------------------------------------------------------------------------------

Some more patterns

-------------------------------------------------------------------------------------------------

• Facade pattern makes interfaces simpler
• Decorator pattern adds responsibility to existing class
• Adapter converts one interface to another
• The factory method is a specialisation of the template method
• Strategy pattern encapsulates interchangeable behaviour and uses delegation to choose one
• Iterator pattern provides a way to traverse collections without exposing internal implementation
• Composite pattern helps client treat collection of objects and objects uniformly
• Observer pattern allows a group of objects to be notified when some state changes
• State pattern encapsulates state-based behaviour and delegates behaviour to the current state

-------------------------------------------------------------------------------------------------

Additional Reading

This contents of this repository are direct or indirect extractions from Head First Design Patterns

-------------------------------------------------------------------------------------------------

Code on GitHub