All Classes and Interfaces
Class
Description
Abstract class defining the template method and the structure of the algorithm.
Abstract Factory interface.
Abstract base class that implements the chaining mechanism.
The Adaptee class provides existing functionality that needs adaptation.
The Adapter class makes the Adaptee compatible with the Target interface.
Interface for creating iterators.
Nonterminal expression representing a logical AND operation in the interpreter pattern.
Abstract interface for constructing a Product.
The Caretaker class manages Memento objects.
Abstract base class for Colleagues in the Mediator Pattern.
The Command interface declares a method for executing commands.
The Component interface declares common operations for both leaf and composite objects.
The Component interface defines operations that can be dynamically modified.
Represents the Composite object in the Composite pattern.
Concrete Aggregate that holds a collection of items.
Concrete implementation of the Builder interface.
Concrete implementation of AbstractClass, providing specific behavior.
Another concrete implementation of AbstractClass, with its own behavior.
Concrete implementation of the Colleague class.
A concrete implementation of the Command interface for Action A.
A concrete implementation of the Command interface for Action B.
A ConcreteComponent provides the base implementation of the Component interface.
Concrete implementation of the Creator class.
Concrete implementation of the Creator class.
A ConcreteDecorator that adds behavior to the Component.
Another ConcreteDecorator that adds behavior to the Component.
Concrete Factory 1.
Concrete Factory 2.
Concrete implementation of the Flyweight interface.
A concrete handler that processes specific requests.
Another concrete handler that processes different requests.
Concrete Iterator for traversing a collection.
Concrete implementation of the Mediator interface.
Concrete implementation of an Observer in the Observer pattern.
Concrete implementation of the Product interface.
Concrete implementation of ProductA for Family 1.
Concrete implementation of ProductA for Family 2.
Concrete implementation of the Product interface.
Concrete implementation of ProductB for Family 1.
Concrete implementation of ProductB for Family 2.
A concrete implementation of the Prototype interface.
Another concrete implementation of the Prototype interface.
Concrete implementation of the Reusable interface.
Concrete implementation of State representing State A.
Concrete implementation of State representing State B.
A Concrete Strategy that implements an algorithm.
Another Concrete Strategy that implements a different algorithm.
Concrete implementation of a Subject in the Observer pattern.
Concrete Visitor implementing specific operations for each element type.
Another Concrete Visitor with different operations for each element type.
Terminal expression representing a boolean constant in the interpreter pattern.
Context class maintaining a reference to a state instance.
The Context class maintains a reference to a Strategy object and delegates the execution to it.
Abstract Creator class in the Factory Method design pattern.
The Decorator class wraps a Component and adds functionality dynamically.
Orchestrates the construction process.
Abstract base class for elements.
Concrete implementation of an element, ElementA.
Concrete implementation of an element, ElementB.
Represents an expression in a simple boolean grammar for the Interpreter design pattern.
The Facade provides a simplified interface to the subsystems.
Flyweight interface for defining common methods that Flyweight objects must implement.
Factory for creating and managing Flyweight objects.
The interface for handling requests in the chain.
The Invoker class stores and executes commands.
Interface for traversing collections.
Represents the Leaf object in the Composite pattern.
Interface for the Mediator in the Mediator Pattern.
The Memento class stores the state of the Originator.
Nonterminal expression representing a logical NOT operation in the interpreter pattern.
Generic Object Pool for managing reusable objects.
ObjectStructure manages a collection of elements and processes them with visitors.
Interface for all observers in the Observer pattern.
Nonterminal expression representing a logical OR operation in the interpreter pattern.
The Originator class creates and restores Memento objects.
Minimal recursive-descent parser for a boolean domain-specific language (DSL).
Represents the complex product being built.
The Product interface defines a common interface for all products
that can be created by the factory method.
Abstract interface for ProductA.
Abstract interface for ProductB.
Interface for the Prototype pattern.
The Proxy controls access to the RealSubject.
The RealSubject performs the actual work of handling requests.
The Receiver class contains the actual business logic for the commands.
Interface for objects managed by the ObjectPool.
Implementation of the Singleton design pattern in Java.
Abstract State interface defining behavior for concrete states.
The Strategy interface declares the common behavior for all supported algorithms.
Abstract class for subjects in the Observer pattern.
The Subject interface defines the common operations for the Proxy and RealSubject.
Subsystem1 provides a specific functionality.
Subsystem2 provides a specific functionality.
Subsystem3 provides a specific functionality.
The Target interface defines the domain-specific interface expected by the client.
Terminal expression representing a variable lookup in the interpreter pattern.
Visitor interface declaring operations for different element types.