Interface Glossary


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

    • PATTERN

      static final @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable Glossary BRIDGE_PATTERN
      Decouple an abstraction from its implementation so that the two can very independently. (See GoF.)
    • COMPOSITE_PATTERN

      static final @Nullable 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 @Nullable 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 @Nullable 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 @Nullable Glossary FLYWEIGHT_PATTERN
      Use sharing to support large numbers of fine-grained objects efficiently. (See GoF.)
    • PROXY_PATTERN

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

      static final @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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.