Command Pattern Explained: Theory, Java Code, and Real‑World Scenarios

What is the Command Pattern?

Each operation is encapsulated in an independent command object. The caller sends a command without needing to know the executor, enabling queuing, undo, and repeat execution.

Purpose: decouple initiator from executor; commands can be stored, rolled back, or executed in bulk.

Typical scenarios

Remote control: buttons are commands, TV is the receiver; channel change, volume adjust are separate commands that can record history.

Software: editor undo/redo, batch task queues, scheduled jobs, button click actions.

Order processing: place, cancel, refund operations wrapped as commands for unified scheduling.

Java implementation (TV remote example)

1. Command interface

public interface Command {
    void execute();
    // undo operation
    void undo();
}

2. Receiver – TV

public class TV {
    public void open(){
        System.out.println("电视开机");
    }
    public void close(){
        System.out.println("电视关机");
    }
}

3. Concrete commands

// Open command
public class OpenTVCommand implements Command{
    private TV tv;
    public OpenTVCommand(TV tv){
        this.tv = tv;
    }
    @Override
    public void execute() {
        tv.open();
    }
    @Override
    public void undo() {
        tv.close();
    }
}

// Close command
public class CloseTVCommand implements Command{
    private TV tv;
    public CloseTVCommand(TV tv){
        this.tv = tv;
    }
    @Override
    public void execute() {
        tv.close();
    }
    @Override
    public void undo() {
        tv.open();
    }
}

4. Invoker – RemoteControl

public class RemoteControl {
    private Command command;
    public void setCommand(Command command){
        this.command = command;
    }
    // press button
    public void press(){
        command.execute();
    }
    // undo previous action
    public void back(){
        command.undo();
    }
}

5. Test driver

public class Test {
    public static void main(String[] args) {
        TV tv = new TV();
        RemoteControl remote = new RemoteControl();

        // execute open
        remote.setCommand(new OpenTVCommand(tv));
        remote.press();
        // undo open, resulting in close
        remote.back();
    }
}

Common business scenarios

Undo/redo needed: document editors, form operation rollback.

Task queues, scheduled or asynchronous batch operations; commands can be cached and queued.

GUI button or menu click events, each click encapsulated as a separate command.

Log operation history for recovery after failures.

Distributed task dispatch, command serialization for transmission.

Advantages and disadvantages

Advantages: decouples operation, supports rollback, enables batch commands.

Disadvantages: each action requires a new command class, increasing the number of classes.