Singleton
Description:
The singleton pattern is a design pattern that ensures a class only has one instance, and provide a global point of access to it.

Motivations:
Single instance of a class to exist in the system Easily accessible

Factory
Description:
The Factory Patterns are creational patterns which abstract the object instantiation process. They hide how objects are created and make the overall system independent of how its objects are created. Class creational patterns focus on the use of inheritance to decide the object to be instantiated in the Factory Pattern.

Motivations:
Let its related subclasses decide which class to instantiate but use the instance as a parent instance Used when the class does not know precisely which class of objects it must

Class Diagram:

Scenario
Factory design pattern works as bridge between multiple classes. An example is using two databases of Oracle and SQL Server. Using SQL at first and it should be changed into Oracle in the future. Without a factory design pattern, all codes have to be modified, but with a factory design pattern, a little work is required. At first, the code should create a database factory according to the database type required. Then, use the factory creating SQL instances to develop the project. You do not need to know what is the type of the database factory and the detail of how it is implemented. When you want to change SQL server to Oracle, modify the implementation of database factory. No furthermore modifications are required.

Abstract Factory
Descriptions:
An Abstract Factory is a Factory of Factories.

Motivations:
Used when you need an interface for creating related objects without specifying their classes. When the system needs to be independent from the way the products it works with are created. If the system is or should be configured to work with multiple families of products. If a family of products is designed to work only all together When the creation of a library of products is needed, for which is relevant only the interface and not the implementation.

Class Diagram:

Scenario
We want to develop a program to create a document automatically according to some custom options. Assume we have two style of documents which are fancy document and modern document and the content of documents contains letter and resume. Then we decide to apply abstract factory design pattern, we create an abstract factory class DocumentCreator that provides interfaces to create a number of products (e.g. createLetter() and createResume() ). The system would have any number of derived concrete versions of the DocumentCreator class like FancyDocumentCreator or ModernDocumentCreator , each with a different implementation of createLetter() and createResume() that would create a corresponding object like FancyLetter or ModernResume . Each of these products is derived from a simple abstract class like Letter or Resume of which the client is aware.

Adapter
Description:

This acts as you would expect as an wrapper between objects and classes. Adapter lets us write the interface without modifying the underlying classes. The adapter gives the interface the clients expect. Lets classes work toghther with could not otherwise due to incompatible interfaces.

Class Diagram:

Observer
Description:
The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.

Motivations:
It is mainly used to implement distributed event handling systems. Heavily used in GUI system for event handling.

Class Diagram:

Scenario
Our APR CW3 is a appropriate example to use Observer Pattern and we did it. In CW3 what we are asked to do is record time and operations when clients try to connect the server. We are only required to write the record into a file, however it is more common to record them in a database. For example, we need record the time and commands into both file and database when the server is visited. We can refer the server as subject and file and database as observer. When the server is visited, it would notify file and database to record. File and database are all implement the Observer interface, so they can be notified by subject and responsed to it with the correspond implementation.

When we want to add another file record system(another file or another database), we can simply let the class implement Observer interface and add it to the list of observers to be notified by the