Practical application of Java design pattern command pattern

Question: How to apply command mode? Steps: Create a command interface to define a common interface for all commands. Implement the command interface to create specific commands and encapsulate specific actions. Create a caller class to send requests to the command. Create a receiver class to perform the action requested by the command.

Java Design Patterns: Practical Application of Command Pattern

Overview

Command A pattern is a behavioral design pattern that provides loose coupling to objects and clients by decoupling requests from the objects that perform them.

How to apply

To implement the command mode, you need to create the following classes:

• Command interface: Define all Public interface for commands.
• Specific commands: Implement the command interface and perform specific actions.
• Caller: Sends a request to the command.
• Receiver: Performs the action requested by the command.

Practical case

The following is a Java example of using the command mode to implement a remote control:

// 命令接口
interface Command {
    void execute();
}

// 具体命令：开电视
class TurnOnCommand implements Command {
    private Television television;

    public TurnOnCommand(Television television) {
        this.television = television;
    }

    @Override
    public void execute() {
        television.turnOn();
    }
}

// 具体命令：关电视
class TurnOffCommand implements Command {
    private Television television;

    public TurnOffCommand(Television television) {
        this.television = television;
    }

    @Override
    public void execute() {
        television.turnOff();
    }
}

// 调用者：遥控器
class RemoteControl {
    private List<Command> commands;

    public RemoteControl() {
        commands = new ArrayList<>();
    }

    public void addCommand(Command command) {
        commands.add(command);
    }

    public void pressButton() {
        for (Command command : commands) {
            command.execute();
        }
    }
}

// 接收者：电视
class Television {
    public void turnOn() {
        System.out.println("电视已打开");
    }

    public void turnOff() {
        System.out.println("电视已关闭");
    }
}

// 主方法
public class Main {
    public static void main(String[] args) {
        // 创建电视
        Television television = new Television();

        // 创建命令
        Command turnOnCommand = new TurnOnCommand(television);
        Command turnOffCommand = new TurnOffCommand(television);

        // 创建遥控器并添加命令
        RemoteControl remoteControl = new RemoteControl();
        remoteControl.addCommand(turnOnCommand);
        remoteControl.addCommand(turnOffCommand);

        // 按下遥控器的按钮
        remoteControl.pressButton();
    }
}

In this example, ## The #TurnOnCommand and TurnOffCommand classes implement the Command interface and encapsulate the actions of turning the TV on and off. RemoteControl The class plays the role of the caller and is responsible for sending requests to the command. Television The class acts as a receiver, receiving and executing the requested action.

In this way, the command pattern decouples actions from the objects that perform them, improving the flexibility, scalability, and maintainability of the system.

The above is the detailed content of Practical application of Java design pattern command pattern. For more information, please follow other related articles on the PHP Chinese website!