Separate the construction of a complex object from its representation so that the same construction process can create different representations.

<br>将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

The classes and objects participating in this pattern are:

* specifies an abstract interface for creating parts of a Product object

* constructs and assembles parts of the product by implementing the Builder interface

* defines and keeps track of the representation it creates

* provides an interface for retrieving the product

* constructs an object using the Builder interface

* represents the complex object under construction. ConcreteBuilder builds the product's internal representation and defines the process by which it's assembled

* includes classes that define the constituent parts, including interfaces for assembling the parts into the final result

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

<br>定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

The classes and objects participating in this pattern are:

* defines the interface of objects the factory method creates

* ConcreteProduct (SkillsPage, EducationPage, ExperiencePage)

* implements the Product interface

* declares the factory method, which returns an object of type Product. Creator may also define a default implementation of the factory method that returns a default ConcreteProduct object.

* may call the factory method to create a Product object.

* overrides the factory method to return an instance of a ConcreteProduct.

Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.

<br>用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

The classes and objects participating in this pattern are:

* declares an interface for cloning itself

* implements an operation for cloning itself

* creates a new object by asking a prototype to clone itself

Ensure a class has only one instance and provide a global point of access to it.

<br>确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

The classes and objects participating in this pattern are:

* defines an Instance operation that lets clients access its unique instance. Instance is a class operation.

* responsible for creating and maintaining its own unique instance.

Decouple an abstraction from its implementation so that the two can vary independently.

<br>将抽象和实现解耦，使得两者可以独立地变化。

The classes and objects participating in this pattern are:

* defines the abstraction's interface.

* maintains a reference to an object of type Implementor.

* extends the interface defined by Abstraction.

* defines the interface for implementation classes. This interface doesn't have to correspond exactly to Abstraction's interface; in fact the two interfaces can be quite different. Typically the Implementation interface provides only primitive operations, and Abstraction defines higher-level operations based on these primitives.

* implements the Implementor interface and defines its concrete implementation.

Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

<br>将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

The classes and objects participating in this pattern are:

* declares the interface for objects in the composition.

* implements default behavior for the interface common to all classes, as appropriate.

* declares an interface for accessing and managing its child components.

* (optional) defines an interface for accessing a component's parent in the recursive structure, and implements it if that's appropriate.

* represents leaf objects in the composition. A leaf has no children.

* defines behavior for primitive objects in the composition.

* defines behavior for components having children.

* stores child components.

* implements child-related operations in the Component interface.

* manipulates objects in the composition through the Component interface.

Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

<br>动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。

The classes and objects participating in this pattern are:

* defines the interface for objects that can have responsibilities added to them dynamically.

* defines an object to which additional responsibilities can be attached.

* maintains a reference to a Component object and defines an interface that conforms to Component's interface.

* adds responsibilities to the component.

Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher-level interface that makes the subsystem easier to use.

<br>要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。外观模式提供一个高层次的接口，使得子系统更易于使用。

The classes and objects participating in this pattern are:

* knows which subsystem classes are responsible for a request.

* delegates client requests to appropriate subsystem objects.

* implement subsystem functionality.

* handle work assigned by the Facade object.

* have no knowledge of the facade and keep no reference to it.

Use sharing to support large numbers of fine-grained objects efficiently.

<br>使用共享对象可有效地支持大量的细粒度的对象。

The classes and objects participating in this pattern are:

* declares an interface through which flyweights can receive and act on extrinsic state.

* implements the Flyweight interface and adds storage for intrinsic state, if any. A ConcreteFlyweight object must be sharable. Any state it stores must be intrinsic, that is, it must be independent of the ConcreteFlyweight object's context.

* not all Flyweight subclasses need to be shared. The Flyweight interface enables sharing, but it doesn't enforce it. It is common for UnsharedConcreteFlyweight objects to have ConcreteFlyweight objects as children at some level in the flyweight object structure (as the Row and Column classes have).

* creates and manages flyweight objects

* ensures that flyweight are shared properly. When a client requests a flyweight, the FlyweightFactory objects assets an existing instance or creates one, if none exists.

* maintains a reference to flyweight(s).

* computes or stores the extrinsic state of flyweight(s).