```
public interface Glossary
```
A collection of terms.
(This is not a real class. It is here so that terms which do not map to classes can be referenced in Javadoc.)

Field Summary

Fields
Modifier and Type	Field	Description
`static Glossary`	`ABSTRACT_FACTORY_PATTERN`	Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
`static Glossary`	`ADAPTER_PATTERN`	Convert the interface of a class into another interface clients expect.
`static Glossary`	`BRIDGE_PATTERN`	Decouple an abstraction from its implementation so that the two can very independently.
`static Glossary`	`BUILDER_PATTERN`	Separate the construction of a complex object from its representation so that the same construction process can create different representations.
`static Glossary`	`CHAIN_OF_RESPONSIBILITY_PATTERN`	Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.
`static Glossary`	`COMMAND_PATTERN`	Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
`static Glossary`	`COMPOSITE_PATTERN`	Compose objects into tree structures to represent part-whole hierarchies.
`static Glossary`	`DECORATOR_PATTERN`	Attach additional responsibilities to an object dynamically.
`static Glossary`	`FACADE_PATTERN`	Provide a unified interface to a set of interfaces in a subsystem.
`static Glossary`	`FACTORY_METHOD_PATTERN`	Define an interface for creating an object, but let subclasses decide which class to instantiate.
`static Glossary`	`FLYWEIGHT_PATTERN`	Use sharing to support large numbers of fine-grained objects efficiently.
`static Glossary`	`INTERPRETER_PATTERN`	Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
`static Glossary`	`ITERATOR_PATTERN`	Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
`static Glossary`	`MEDIATOR_PATTERN`	Define an object that encapsulates how a set of objects interact.
`static Glossary`	`MEMENTO_PATTERN`	Without violating encapsulation, capture and externalize an objects's internal state so that the object can be restored to this state later.
`static Glossary`	`OBSERVER_PATTERN`	Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
`static Glossary`	`PATTERN`	This table shows how and where the Gang of Four patterns are applied.
`static Glossary`	`PROTOTYPE_PATTERN`	Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
`static Glossary`	`PROXY_PATTERN`	Provide a surrogate or placeholder for another object to control access to it.
`static Glossary`	`SINGLETON_PATTERN`	Ensure a class only has one instance, and provide a global point of access to it.
`static Glossary`	`SQL2003`	The official SQL:2003 standard (ISO/IEC 9075:2003), which is broken up into numerous parts.
`static Glossary`	`SQL92`	The official SQL-92 standard (ISO/IEC 9075:1992).
`static Glossary`	`SQL99`	The official SQL:1999 standard (ISO/IEC 9075:1999), which is broken up into five parts.
`static Glossary`	`STATE_PATTERN`	Allow an object to alter its behavior when its internal state changes.
`static Glossary`	`STRATEGY_PATTERN`	Define a family of algorithms, encapsulate each one, and make them interchangeable.
`static Glossary`	`TEMPLATE_METHOD_PATTERN`	Define the skeleton of an algorithm in an operation, deferring some steps to subclasses.
`static Glossary`	`VISITOR_PATTERN`	Represent an operation to be performed on the elements of an object structure.

Field Detail

PATTERN

static final Glossary PATTERN

This table shows how and where the Gang of Four patterns are applied. The table uses information from the GoF book and from a course on advanced object design taught by Craig Larman.

The patterns are in three groups depicting frequency of use. The patterns in light green are used frequently. Those in yellow have moderate use. Patterns in red are infrequently used. The GoF column gives the original Gang Of Four category for the pattern. The Problem and Pattern columns are from Craig's refinement of the type of problems they apply to and a refinement of the original three pattern categories.

**Gang of Four Patterns**
Pattern Name	GOF Category	Problem	Pattern	Often Uses	Related To
Abstract Factory	Creational	Creating Instances	Class/Interface Definition plus Inheritance	Factory Method Prototype Singleton with Facade	Factory Method Prototype Singleton
Object Adapter	Structural	Interface	Wrap One	-	Bridge Decorator Proxy
Command	Behavioral	Organization or Communication of Work Action/Response	Behavior Objects	Composite	Composite Memento Prototype
Composite	Structural	Structural Decomposition of Objects or Subsystems	Wrap Many	-	Decorator Iterator Visitor
Decorator	Structural	Instance Behavior	Wrap One	-	Object Adapter Composite Strategy
Facade	Structural	Access Control Structural Decomposition of Objects or Subsystems	Wrap Many	Singleton with Abstract Factory	Abstract Factory Mediator
Flyweight	Structural	Shared Resource Handling	Object State or Values	-	Singleton State Strategy Shareable
Iterator	Behavioral	Traversal Algorithm Access Control	Low Coupling	-	Composite Factory Method Memento
Observer	Behavioral	Event Response Organization or Communication of Work	Low Coupling	-	Mediator Singleton
Proxy	Structural	Access Control	Wrap One	-	Adapter Decorator
Singleton	Creational	Access Control	Other	-	Abstract Factory Builder Prototype
State	Behavioral	Instance Behavior	Object State or Values	Flyweight	Flyweight Singleton
Strategy	Behavioral	Single Algorithm	Behavior Objects	-	Flyweight State Template Method
Template Method	Behavioral	Single Algorithm	Class or Interface Definition plus Inheritance	-	Strategy
Class Adapter	Structural	Interface	Class or Interface Definition plus Inheritance	-	Bridge Decorator Proxy
Bridge	Structural	Implementation	Wrap One	-	Abstract Factory Class Adaptor
Builder	Creational	Creating Structures	Class or Interface Definition plus Inheritance	-	Abstract Factory Composite
Chain of Responsibility	Behavioral	Single Algorithm Organization or Communication of Work	Low Coupling	-	Composite
Factory Method	Creational	Creating Instances	Class or Interface Definition plus Inheritance	Template Method	Abstract Factory Template Method Prototype
Mediator	Behavioral	Interaction between Objects Organization or Communication of Work	Low Coupling	-	Facade Observer
Prototype	Creational	Creating Instances	Other	-	Prototype Composite Decorator
Visitor	Behavioral	Single Algorithm	Behavior Objects	-	Composite Visitor
Interpreter	Behavioral	Organization or Communication of Work	Other	-	Composite Flyweight Iterator Visitor
Memento	Behavioral	Instance Management	Object State or Values	-	Command Iterator

ABSTRACT_FACTORY_PATTERN
```
static final Glossary ABSTRACT_FACTORY_PATTERN
```
Provide an interface for creating families of related or dependent objects without specifying their concrete classes. (See GoF.)

BUILDER_PATTERN
```
static final Glossary BUILDER_PATTERN
```
Separate the construction of a complex object from its representation so that the same construction process can create different representations. (See GoF.)

FACTORY_METHOD_PATTERN
```
static final Glossary FACTORY_METHOD_PATTERN
```
Define an interface for creating an object, but let subclasses decide which class to instantiate. Lets a class defer instantiation to subclasses. (See GoF.)

PROTOTYPE_PATTERN
```
static final Glossary PROTOTYPE_PATTERN
```
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype. (See GoF.)

SINGLETON_PATTERN
```
static final Glossary SINGLETON_PATTERN
```
Ensure a class only has one instance, and provide a global point of access to it. (See GoF.)
Note that a common way of implementing a singleton, the so-called double-checked locking pattern, is fatally flawed in Java. Don't use it!

ADAPTER_PATTERN
```
static final Glossary ADAPTER_PATTERN
```
Convert the interface of a class into another interface clients expect. Lets classes work together that couldn't otherwise because of incompatible interfaces. (See GoF.)

BRIDGE_PATTERN
```
static final Glossary BRIDGE_PATTERN
```
Decouple an abstraction from its implementation so that the two can very independently. (See GoF.)

COMPOSITE_PATTERN
```
static final Glossary COMPOSITE_PATTERN
```
Compose objects into tree structures to represent part-whole hierarchies. Lets clients treat individual objects and compositions of objects uniformly. (See GoF.)

DECORATOR_PATTERN
```
static final Glossary DECORATOR_PATTERN
```
Attach additional responsibilities to an object dynamically. Provides a flexible alternative to subclassing for extending functionality. (See GoF.)

FACADE_PATTERN
```
static final Glossary FACADE_PATTERN
```
Provide a unified interface to a set of interfaces in a subsystem. Defines a higher-level interface that makes the subsystem easier to use. (See GoF.)

FLYWEIGHT_PATTERN
```
static final Glossary FLYWEIGHT_PATTERN
```
Use sharing to support large numbers of fine-grained objects efficiently. (See GoF.)

PROXY_PATTERN
```
static final Glossary PROXY_PATTERN
```
Provide a surrogate or placeholder for another object to control access to it. (See GoF.)

CHAIN_OF_RESPONSIBILITY_PATTERN
```
static final Glossary CHAIN_OF_RESPONSIBILITY_PATTERN
```
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. (See GoF.)

COMMAND_PATTERN
```
static final Glossary COMMAND_PATTERN
```
Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations. (See GoF.)

INTERPRETER_PATTERN
```
static final Glossary INTERPRETER_PATTERN
```
Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language. (See GoF.)

ITERATOR_PATTERN
```
static final Glossary ITERATOR_PATTERN
```
Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation. (See GoF.)

MEDIATOR_PATTERN
```
static final Glossary MEDIATOR_PATTERN
```
Define an object that encapsulates how a set of objects interact. Promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently. (See GoF.)

MEMENTO_PATTERN
```
static final Glossary MEMENTO_PATTERN
```
Without violating encapsulation, capture and externalize an objects's internal state so that the object can be restored to this state later. (See GoF.)

OBSERVER_PATTERN
```
static final Glossary OBSERVER_PATTERN
```
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. (See GoF.)

STATE_PATTERN
```
static final Glossary STATE_PATTERN
```
Allow an object to alter its behavior when its internal state changes. The object will appear to change its class. (See GoF.)

STRATEGY_PATTERN
```
static final Glossary STRATEGY_PATTERN
```
Define a family of algorithms, encapsulate each one, and make them interchangeable. Lets the algorithm vary independently from clients that use it. (See GoF.)

TEMPLATE_METHOD_PATTERN
```
static final Glossary TEMPLATE_METHOD_PATTERN
```
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure. (See GoF.)

VISITOR_PATTERN
```
static final Glossary VISITOR_PATTERN
```
Represent an operation to be performed on the elements of an object structure. Lets you define a new operation without changing the classes of the elements on which it operates. (See GoF.)

SQL92
```
static final Glossary SQL92
```
The official SQL-92 standard (ISO/IEC 9075:1992). To reference this standard from methods that implement its rules, use the @sql.92 custom block tag in Javadoc comments; for the tag body, use the format <SectionId> [ ItemType <ItemId> ], where
- SectionId is the numbered or named section in the table of contents, e.g. "Section 4.18.9" or "Annex A"
- ItemType is one of { Table, Syntax Rule, Access Rule, General Rule, or Leveling Rule }
- ItemId is a dotted path expression to the specific item
For example,
```
@sql.92 Section 11.4 Syntax Rule 7.c
 
```
is a well-formed reference to the rule for the default character set to use for column definitions of character type.
Note that this tag is a block tag (like @see) and cannot be used inline.

SQL99
```
static final Glossary SQL99
```
The official SQL:1999 standard (ISO/IEC 9075:1999), which is broken up into five parts. To reference this standard from methods that implement its rules, use the @sql.99 custom block tag in Javadoc comments; for the tag body, use the format <PartId> <SectionId> [ ItemType <ItemId> ], where
- PartId is the numbered part (up to Part 5)
- SectionId is the numbered or named section in the part's table of contents, e.g. "Section 4.18.9" or "Annex A"
- ItemType is one of { Table, Syntax Rule, Access Rule, General Rule, or Conformance Rule }
- ItemId is a dotted path expression to the specific item
For example,
```
@sql.99 Part 2 Section 11.4 Syntax Rule 7.b
 
```
is a well-formed reference to the rule for the default character set to use for column definitions of character type.
Note that this tag is a block tag (like @see) and cannot be used inline.

SQL2003
```
static final Glossary SQL2003
```
The official SQL:2003 standard (ISO/IEC 9075:2003), which is broken up into numerous parts. To reference this standard from methods that implement its rules, use the @sql.2003 custom block tag in Javadoc comments; for the tag body, use the format <PartId> <SectionId> [ ItemType <ItemId> ], where
- PartId is the numbered part
- SectionId is the numbered or named section in the part's table of contents, e.g. "Section 4.11.2" or "Annex A"
- ItemType is one of { Table, Syntax Rule, Access Rule, General Rule, or Conformance Rule }
- ItemId is a dotted path expression to the specific item
For example,
```
@sql.2003 Part 2 Section 11.4 Syntax Rule 10.b
 
```
is a well-formed reference to the rule for the default character set to use for column definitions of character type.
Note that this tag is a block tag (like @see) and cannot be used inline.

Interface Glossary

Field Summary

Field Detail

PATTERN

ABSTRACT_FACTORY_PATTERN

BUILDER_PATTERN

FACTORY_METHOD_PATTERN

PROTOTYPE_PATTERN

SINGLETON_PATTERN

ADAPTER_PATTERN

BRIDGE_PATTERN

COMPOSITE_PATTERN

DECORATOR_PATTERN

FACADE_PATTERN

FLYWEIGHT_PATTERN

PROXY_PATTERN

CHAIN_OF_RESPONSIBILITY_PATTERN

COMMAND_PATTERN

INTERPRETER_PATTERN

ITERATOR_PATTERN

MEDIATOR_PATTERN

MEMENTO_PATTERN

OBSERVER_PATTERN

STATE_PATTERN

STRATEGY_PATTERN

TEMPLATE_METHOD_PATTERN

VISITOR_PATTERN

SQL92

SQL99

SQL2003