Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

<br>使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

The classes and objects participating in this pattern are:

* defines an interface for handling the requests

* (optional) implements the successor link

* handles requests it is responsible for

* can access its successor

* if the ConcreteHandler can handle the request, it does so; otherwise it forwards the request to its successor

* initiates the request to a ConcreteHandler object on the chain

Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

<br>给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

The classes and objects participating in this pattern are:

* declares an interface for executing an operation

* implements an Interpret operation associated with terminal symbols in the grammar.

* an instance is required for every terminal symbol in the sentence.

* one such class is required for every rule R ::= R1R2...Rn in the grammar

* maintains instance variables of type AbstractExpression for each of the symbols R1 through Rn.

* implements an Interpret operation for nonterminal symbols in the grammar. Interpret typically calls itself recursively on the variables representing R1 through Rn.

* contains information that is global to the interpreter

* builds (or is given) an abstract syntax tree representing a particular sentence in the language that the grammar defines. The abstract syntax tree is assembled from instances of the NonterminalExpression and TerminalExpression classes

* invokes the Interpret operation

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

<br>提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。

The classes and objects participating in this pattern are:

* defines an interface for accessing and traversing elements.

* implements the Iterator interface.

* keeps track of the current position in the traversal of the aggregate.

* defines an interface for creating an Iterator object

* implements the Iterator creation interface to return an instance of the proper ConcreteIterator

Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

<br>用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

The classes and objects participating in this pattern are:

* defines an interface for communicating with Colleague objects

* implements cooperative behavior by coordinating Colleague objects

* knows and maintains its colleagues

* each Colleague class knows its Mediator object

* each colleague communicates with its mediator whenever it would have otherwise communicated with another colleague

Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.

<br>在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

The classes and objects participating in this pattern are:

* stores internal state of the Originator object. The memento may store as much or as little of the originator's internal state as necessary at its originator's discretion.

* protect against access by objects of other than the originator. Mementos have effectively two interfaces. Caretaker sees a narrow interface to the Memento -- it can only pass the memento to the other objects. Originator, in contrast, sees a wide interface, one that lets it access all the data necessary to restore itself to its previous state. Ideally, only the originator that produces the memento would be permitted to access the memento's internal state.

* creates a memento containing a snapshot of its current internal state.

* uses the memento to restore its internal state

* is responsible for the memento's safekeeping

* never operates on or examines the contents of a memento.

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

<br>定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

The classes and objects participating in this pattern are:

* knows its observers. Any number of Observer objects may observe a subject

* provides an interface for attaching and detaching Observer objects.

* stores state of interest to ConcreteObserver

* sends a notification to its observers when its state changes

* defines an updating interface for objects that should be notified of changes in a subject.

* maintains a reference to a ConcreteSubject object

* stores state that should stay consistent with the subject's

* implements the Observer updating interface to keep its state consistent with the subject's

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

<br>定义一组算法，将每个算法都封装起来，并且使它们之间可以互换

The classes and objects participating in this pattern are:

* declares an interface common to all supported algorithms. Context uses this interface to call the algorithm defined by a ConcreteStrategy

* implements the algorithm using the Strategy interface

* is configured with a ConcreteStrategy object

* maintains a reference to a Strategy object

* may define an interface that lets Strategy access its data.

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.

<br>定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

The classes and objects participating in this pattern are:

* defines abstract primitive operations that concrete subclasses define to implement steps of an algorithm

* implements a template method defining the skeleton of an algorithm. The template method calls primitive operations as well as operations defined in AbstractClass or those of other objects.

* implements the primitive operations ot carry out subclass-specific steps of the algorithm

Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.

<br>封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

The classes and objects participating in this pattern are:

* declares a Visit operation for each class of ConcreteElement in the object structure. The operation's name and signature identifies the class that sends the Visit request to the visitor. That lets the visitor determine the concrete class of the element being visited. Then the visitor can access the elements directly through its particular interface

* implements each operation declared by Visitor. Each operation implements a fragment of the algorithm defined for the corresponding class or object in the structure. ConcreteVisitor provides the context for the algorithm and stores its local state. This state often accumulates results during the traversal of the structure.

* defines an Accept operation that takes a visitor as an argument.

* implements an Accept operation that takes a visitor as an argument

* can enumerate its elements

* may provide a high-level interface to allow the visitor to visit its elements

* may either be a Composite (pattern) or a collection such as a list or a set