Implementation

The class diagram of the command pattern is as follows:

We can distinguish the following actors in the preceding implementation diagram:

• Command: This is the abstraction that represents the encapsulation of a command. It declares the abstract method executed, which should be implemented by all the concrete commands.
• ConcreteCommand: This is the actual implementation of the Command. It has to execute the command and deal with the parameters associated with each concrete command. It delegates the command to the receiver.
• Receiver: This is the class responsible for executing the action associated with the command.
• Invoker: This is the class that triggers the command. This is usually an external event, such as a user action.
• Client: This is the actual class that instantiates the concrete command objects and their receivers.

Initially, our impulse is to deal with all possible commands in a big if-else block:

public void performAction(ActionEvent e)
{
  Object obj = e.getSource();
  if (obj = fileNewMenuItem)
  doFileNewAction();
  else if (obj = fileOpenMenuItem)
  doFileOpenAction();
  else if (obj = fileOpenRecentMenuItem)
  doFileOpenRecentAction();
  else if (obj = fileSaveMenuItem)
  doFileSaveAction();
}

However, we may decide to apply the command pattern for the drawing application. We start by creating a command interface:

public interface Command
{
  public void execute();
}

The next step is to define all the objects, such as menu items and buttons, as classes, implementing the command interface and the execute() method:

public class OpenMenuItem extends JMenuItem implements Command
{
  public void execute()  
  {
    // code to open a document
  }
}

After we have repeated the previous operation, creating a class for each possible action, we replace the if-else block from the naive implementation with the following one:

public void performAction(ActionEvent e)
{
  Command command = (Command)e.getSource();
  command.execute();
}

We can see from our code that the invoker (the client that triggers the performAction method) and the receivers (the classes implementing the command interface) are decoupled. We can easily extend our code without changing it.