Command Design Pattern example
Imagine you are tasked with designing a remote control system for various electronic devices in a smart home. The devices include a TV, a stereo, and potentially other appliances. The goal is to create a flexible remote control that can handle different types of commands for each device, such as turning devices on/off, adjusting settings, or changing channels.
What can be the challenges while implementing this system?
- First challenges is that devices can have different functionalities, so designing a remote control that can seamlessly handle different device types with varying functionalities without becoming overly complex or device-specific.
- Implementing a remote control that supports various commands without tightly coupling ensuring the remote control can execute commands for different devices without needing extensive modifications for each new command or device type.
- Designing a system that allows users to customize the behavior of the remote control dynamically
How Command Pattern help to solve above challenges?
The Command Pattern can be employed to address these challenges. It introduces a level of abstraction between the sender of a command (remote control) and the receiver of the command (electronic devices).
- The Command Pattern decouples the sender (Invoker) from the receiver (Devices). The remote control doesn’t need to know the specific details of how each device operates; it only triggers commands.
- New devices or commands can be added without modifying existing code. The remote control can work with any device that implements the common command interface.
- The remote control can dynamically change its behavior by associating different commands.
Below is the code of above problem statement using Command Pattern:
1. Command Interface
The Command
interface declares a method, often named execute()
. This method is meant to encapsulate a specific operation. The interface sets a contract for concrete command classes, defining the execute()
method that encapsulates the operation to be performed.
Java
// Command interface public interface Command { void execute(); } |
2. Concrete Command Classes
Concrete command classes implement the Command
interface. Each class encapsulates a specific operation related to devices. Each concrete command class provides a specific implementation of the execute()
method, defining how a particular device operation (turning on, turning off, adjusting volume, changing channel) is executed.
Java
// Concrete command for turning a device on public class TurnOnCommand implements Command { private Device device; public TurnOnCommand(Device device) { this .device = device; } @Override public void execute() { device.turnOn(); } } // Concrete command for turning a device off public class TurnOffCommand implements Command { private Device device; public TurnOffCommand(Device device) { this .device = device; } @Override public void execute() { device.turnOff(); } } // Concrete command for adjusting the volume of a stereo public class AdjustVolumeCommand implements Command { private Stereo stereo; public AdjustVolumeCommand(Stereo stereo) { this .stereo = stereo; } @Override public void execute() { stereo.adjustVolume(); } } // Concrete command for changing the channel of a TV public class ChangeChannelCommand implements Command { private TV tv; public ChangeChannelCommand(TV tv) { this .tv = tv; } @Override public void execute() { tv.changeChannel(); } } |
3. Receiver Classes (Devices)
The Device
interface declares methods related to device functionality, such as turnOn()
and turnOff()
. This interface sets a contract for device classes, defining common operations that concrete devices should support.
Java
// Receiver interface public interface Device { void turnOn(); void turnOff(); } // Concrete receiver for a TV public class TV implements Device { @Override public void turnOn() { System.out.println( "TV is now on" ); } @Override public void turnOff() { System.out.println( "TV is now off" ); } public void changeChannel() { System.out.println( "Channel changed" ); } } // Concrete receiver for a stereo public class Stereo implements Device { @Override public void turnOn() { System.out.println( "Stereo is now on" ); } @Override public void turnOff() { System.out.println( "Stereo is now off" ); } public void adjustVolume() { System.out.println( "Volume adjusted" ); } } |
4. Invoker Class (Remote Control):
The invoker class holds a reference to a Command
object and triggers its execution through the execute()
method. The invoker doesn’t know the specific details of the command or the devices. It simply calls the execute()
method on the current command, allowing for flexible and dynamic control over different devices.
Java
// Invoker public class RemoteControl { private Command command; public void setCommand(Command command) { this .command = command; } public void pressButton() { command.execute(); } } |
Complete code for the above example
Below is the complete code for the above example:
Java
// Command interface interface Command { void execute(); } // Concrete command for turning a device on class TurnOnCommand implements Command { private Device device; public TurnOnCommand(Device device) { this .device = device; } @Override public void execute() { device.turnOn(); } } // Concrete command for turning a device off class TurnOffCommand implements Command { private Device device; public TurnOffCommand(Device device) { this .device = device; } @Override public void execute() { device.turnOff(); } } // Concrete command for adjusting the volume of a stereo class AdjustVolumeCommand implements Command { private Stereo stereo; public AdjustVolumeCommand(Stereo stereo) { this .stereo = stereo; } @Override public void execute() { stereo.adjustVolume(); } } // Concrete command for changing the channel of a TV class ChangeChannelCommand implements Command { private TV tv; public ChangeChannelCommand(TV tv) { this .tv = tv; } @Override public void execute() { tv.changeChannel(); } } // Receiver interface interface Device { void turnOn(); void turnOff(); } // Concrete receiver for a TV class TV implements Device { @Override public void turnOn() { System.out.println( "TV is now on" ); } @Override public void turnOff() { System.out.println( "TV is now off" ); } public void changeChannel() { System.out.println( "Channel changed" ); } } // Concrete receiver for a stereo class Stereo implements Device { @Override public void turnOn() { System.out.println( "Stereo is now on" ); } @Override public void turnOff() { System.out.println( "Stereo is now off" ); } public void adjustVolume() { System.out.println( "Volume adjusted" ); } } // Invoker class RemoteControl { private Command command; public void setCommand(Command command) { this .command = command; } public void pressButton() { command.execute(); } } // Example usage public class CommandPatternExample { public static void main(String[] args) { // Create devices TV tv = new TV(); Stereo stereo = new Stereo(); // Create command objects Command turnOnTVCommand = new TurnOnCommand(tv); Command turnOffTVCommand = new TurnOffCommand(tv); Command adjustVolumeStereoCommand = new AdjustVolumeCommand(stereo); Command changeChannelTVCommand = new ChangeChannelCommand(tv); // Create remote control RemoteControl remote = new RemoteControl(); // Set and execute commands remote.setCommand(turnOnTVCommand); remote.pressButton(); // Outputs: TV is now on remote.setCommand(adjustVolumeStereoCommand); remote.pressButton(); // Outputs: Volume adjusted remote.setCommand(changeChannelTVCommand); remote.pressButton(); // Outputs: Channel changed remote.setCommand(turnOffTVCommand); remote.pressButton(); // Outputs: TV is now off } } |
Output
TV is now on Volume adjusted Channel changed TV is now off |
Command Design Pattern
The Command Design Pattern is a behavioral design pattern that turns a request into a stand-alone object, allowing parameterization of clients with different requests, queuing of requests, and support for undoable operations(action or a series of actions that can be reversed or undone in a system).
Important Topics for the Command Design Pattern
- What is the Command Design Pattern?
- Components of the Command Design Pattern
- Command Design Pattern example
- When to use the Command Design Pattern
- When not to use the Command Design Pattern