Command Pattern: Encapsulating Requests as Objects

// VIOLATION: invoker directly coupled to receiver's concrete API
class RemoteButton {
    private Light light;
 
    RemoteButton(Light light) { this.light = light; }
 
    void press() {
        light.turnOn(); // hardcoded action — this button can only ever do this one thing
        // No way to: queue this for later, log it, undo it, or
        // reprogram this button to control a Fan instead without editing this class.
    }
}
 
class Light {
    void turnOn() { System.out.println("Light ON"); }
    void turnOff() { System.out.println("Light OFF"); }
}

// The Receiver — the object that actually does the work
class Light {
    private boolean isOn = false;
 
    void turnOn() { isOn = true; System.out.println("Light ON"); }
    void turnOff() { isOn = false; System.out.println("Light OFF"); }
}
 
// The Command interface — every action supports execute AND its inverse
interface Command {
    void execute();
    void undo();
}
 
class LightOnCommand implements Command {
    private final Light light;
    LightOnCommand(Light light) { this.light = light; }
 
    @Override
    public void execute() { light.turnOn(); }
 
    @Override
    public void undo() { light.turnOff(); } // inverse of execute
}
 
class LightOffCommand implements Command {
    private final Light light;
    LightOffCommand(Light light) { this.light = light; }
 
    @Override
    public void execute() { light.turnOff(); }
 
    @Override
    public void undo() { light.turnOn(); }
}
 
// The Invoker — knows only the Command interface, never the receiver
class RemoteControl {
    private final Deque<Command> history = new ArrayDeque<>();
 
    void pressButton(Command command) {
        command.execute();
        history.push(command); // record for undo
    }
 
    void pressUndo() {
        if (!history.isEmpty()) {
            history.pop().undo();
        }
    }
}
 
class Demo {
    public static void main(String[] args) {
        Light livingRoomLight = new Light();
        RemoteControl remote = new RemoteControl();
 
        remote.pressButton(new LightOnCommand(livingRoomLight));   // Light ON
        remote.pressButton(new LightOffCommand(livingRoomLight));  // Light OFF
        remote.pressUndo();                                        // Light ON (undoes the OFF)
        remote.pressUndo();                                        // Light OFF (undoes the ON)
 
        // Reprogramming the remote to control a Fan needs zero changes to RemoteControl —
        // just a new Command implementation.
    }
}

// A macro command: one press executes an entire sequence, undo reverses it in order
class MacroCommand implements Command {
    private final List<Command> commands;
 
    MacroCommand(List<Command> commands) { this.commands = commands; }
 
    @Override
    public void execute() {
        for (Command command : commands) command.execute();
    }
 
    @Override
    public void undo() {
        // undo in REVERSE order — critical for correctness when commands depend on each other
        for (int i = commands.size() - 1; i >= 0; i--) {
            commands.get(i).undo();
        }
    }
}
 
// "Good night" scene: one button press, several receivers
Command goodNight = new MacroCommand(List.of(
    new LightOffCommand(livingRoomLight),
    new LightOffCommand(bedroomLight),
    new LockDoorCommand(frontDoor)
));
remote.pressButton(goodNight); // executes all three
remote.pressUndo();            // reverses all three, in reverse order

interface TransactionalCommand {
    void execute() throws Exception;
    void rollback();
}
 
class TransactionRunner {
    private final Deque<TransactionalCommand> completed = new ArrayDeque<>();
 
    void run(List<TransactionalCommand> steps) {
        try {
            for (TransactionalCommand step : steps) {
                step.execute();
                completed.push(step); // only tracked after success
            }
        } catch (Exception e) {
            System.err.println("Transaction failed, rolling back: " + e.getMessage());
            while (!completed.isEmpty()) {
                completed.pop().rollback(); // undo only what actually succeeded
            }
        }
    }
}
// Steps like ReserveInventoryCommand, ChargeCardCommand, CreateShipmentCommand
// each implement execute()/rollback() — if ChargeCardCommand throws,
// only ReserveInventoryCommand needs rollback(), and the runner knows that
// precisely because it tracked what actually completed.