Command Design pattern by Java Example

Definition:

The Command Design Pattern is a behavioral design pattern that encapsulates a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations. This pattern provides a way to decouple the sender of a request from the object that handles the request, promoting the principles of loose coupling and separation of concerns.

Key Components:

1. Command Interface: This defines the interface for executing a command. It typically has a method execute().
2. Concrete Command: These are classes that implement the Command interface, containing the implementation of the execute() method. They also hold a reference to the receiver object.
3. Receiver: This is the object that knows how to perform the operations associated with the command. It contains the actual business logic.
4. Invoker: The invoker holds a command and at some point asks the command to execute. It doesn’t know what the command does, just that it can execute a command.
5. Client: The client is responsible for creating the command object and setting its receiver.

Benefits:

1- Decoupling: The sender and receiver are decoupled, meaning they can vary independently.

2- Extensibility: New commands can be added easily without changing existing code.

3- Undo/Redo functionality: Commands can be stored in a history stack, enabling easy implementation of undo/redo functionality.

4- Logging and Audit: Commands can be logged, providing a trail of executed actions.

Example Code

Let’s create a simple text editor scenario where we can type commands such as "copy", "paste", and "cut".

Step 1: Define Command Interface

Step 2: Implement Concrete Commands

Step 3: Implement the Receiver

Step 4: Implement the Invoker

Step 5: Create a Client to Test the Command Pattern

Explanation

1. Text Editor: The TextEditor class is the receiver that knows how to perform the operations (copy, paste, and cut).
2. Commands: Each command (Copy, Paste, Cut) implements the Command interface and calls the appropriate methods on the TextEditor.
3. Invoker: The CommandInvoker is responsible for executing the commands. It doesn't know the specifics of the command; it just calls the execute method.
4. Client: In the Client class, we create TextEditor, commands, and invoke commands through the CommandInvoker.

This structure allows for easy addition of new commands and extensibility while adhering to the Open/Closed Principle of design.