Command Pattern

Welcome to the lesson on the Command Pattern! This pattern is an essential part of Behavioral Design Patterns and focuses on encapsulating a request as an object. In this way, you can parameterize clients with different requests, queue them, log them, and even support undo operations. It's commonly used in scenarios where you need to decouple the object that invokes an operation from the object that performs it.

What You Will Learn

In this lesson, you will: Understand the basics of the Command Pattern . Learn how to implement this pattern in Java . Recognize the significance of the Command Pattern in real-world applications.

Implementing the Command Pattern

The Command Pattern is a behavioral design pattern that turns a request into a stand-alone object that contains all the information about the request. This transformation allows you to parameterize methods with different requests, queue requests, and log their execution, among other things. At its core, it decouples the object that initiates an action from the object that performs the action. Let's break down the implementation step-by-step using our example of a remote control for a light. We'll create commands to turn the light on and off, demonstrating the flexibility and reusability of the Command Pattern .

Step 1: Define the Command Interface

Java public interface Command {void execute();} The Command interface defines a method called execute, which encapsulates an action. Any class implementing this interface must provide an implementation for the execute method.

Step 2: Implement the Receiver Class

Java public class Light {public void on() {System.out.println("Light is on.");} public void off() {System.out.println("Light is off.");}} The Light class is our receiver. It contains the business logic to turn the light on or off.

Step 3: Implement Concrete Command for Turning the Light On

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Java

public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

The LightOnCommand class implements the Command interface. It has a reference to the Light object and calls its on method when execute is invoked.

Java

public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

The LightOffCommand class also implements the Command interface. It has a reference to the Light object and calls its off method when execute is invoked.

Java

public class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

public class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

The RemoteControl class acts as the invoker. It holds a reference to a Command object and executes it when the button is pressed.

Java

public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        Command lightOn = new LightOnCommand(light);
        Command lightOff = new LightOffCommand(light);

        RemoteControl remote = new RemoteControl();
        remote.setCommand(lightOn);
        remote.pressButton();  // Outputs: Light is on.
        remote.setCommand(lightOff);
        remote.pressButton();  // Outputs: Light is off.
    }
}

public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        Command lightOn = new LightOnCommand(light);
        Command lightOff = new LightOffCommand(light);

        RemoteControl remote = new RemoteControl();
        remote.setCommand(lightOn);
        remote.pressButton();  // Outputs: Light is on.
        remote.setCommand(lightOff);
        remote.pressButton();  // Outputs: Light is off.
    }
}

In the Main class, we create the Light receiver, and the LightOnCommand and LightOffCommand concrete commands. We then create a RemoteControl invoker, set the commands, and execute them to see the results.

The Command Pattern is especially useful for:

Decoupling: It decouples the object that requests an operation (invoker) from the one that actually performs the operation (receiver).
Reusability: Commands can be reused and combined in complex scenarios, enhancing code maintainability and flexibility.
History and Undo: It allows for adding history and undo features, crucial in applications like text editors, where users may want to revert actions.
Logging: Commands can be logged, enabling actions to be recorded and replayed, useful for debugging and auditing purposes.

By the end of this lesson, you'll be more confident in applying the Command Pattern to your projects. Are you ready to practice and see this pattern in action? Let's move on to the practice section and enhance your coding skills!

Command Pattern

What You Will Learn

Implementing the Command Pattern

Step 1: Define the Command Interface

Step 2: Implement the Receiver Class

Step 3: Implement Concrete Command for Turning the Light On

Join the 1M+ learners on CodeSignal

Step 4: Implement Concrete Command for Turning the Light Off

Step 5: Implement the Invoker Class

Step 6: Putting It All Together in the Main Class

Why It Is Important