命令模式：將請求封裝為對象-魔扣目錄

什么是命令模式？

命令模式是一種行為型設計模式，它將請求或操作封裝成獨立的命令對象。這些命令對象包括了執行操作所需的所有信息，例如操作方法、參數和接收者。

命令模式允許您將命令發送者（客戶端）和命令執行者（接收者）解耦，使得發送者無需知道接收者的具體類別。

在命令模式中，通常包含以下關鍵角色：

命令（Command）：聲明了執行操作的接口，通常包括一個 execute 方法。
具體命令（Concrete Command）：實現了命令接口，包含了實際的操作邏輯。每個具體命令對象都與一個接收者相關聯。
接收者（Receiver）：執行命令實際操作的對象。
調用者（Invoker）：負責調用命令對象來執行請求。
客戶端（Client）：創建命令對象并設置其接收者，然后將命令對象傳遞給調用者。

為什么需要命令模式？

命令模式有以下幾個優點：

解耦：命令模式可以將發送者和接收者解耦，發送者無需知道接收者的具體實現，從而提高了系統的靈活性。
可擴展性：您可以輕松地添加新的命令類，而無需修改已有的代碼。
撤銷操作：命令對象通常會保存操作的狀態，從而支持撤銷操作。
日志記錄和事務管理：您可以使用命令模式來記錄所有執行的命令，以便進行事務管理或撤銷。

命令模式的實現

讓我們通過一個簡單的示例來演示命令模式的實現。假設我們正在構建一個遙控器應用，用戶可以通過遙控器執行不同的操作，例如打開電視、切換頻道和調整音量。

首先，我們定義一個命令接口 Command，它包括了一個 execute 方法：

public interface Command {
void execute();
}

接下來，我們創建具體的命令類，例如 TurnOnCommand、ChangeChannelCommand 和 AdjustVolumeCommand，它們實現了 Command 接口，并分別執行相應的操作。

public class TurnOnCommand implements Command {
private Television television;

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

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

// 類似地實現 ChangeChannelCommand 和 AdjustVolumeCommand

然后，我們創建接收者類 Television，它包含了實際的操作邏輯：

public class Television {
public void turnOn() {
System.out.println("電視已打開");
}

public void changeChannel() {
System.out.println("切換頻道");
}

public void adjustVolume() {
System.out.println("調整音量");
}
}

最后，我們創建調用者類 RemoteControl，它接收并執行命令：

public class RemoteControl {
private Command command;

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

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

客戶端代碼如下：

public class Client {
public static void mAIn(String[] args) {
Television television = new Television();

Command turnOnCommand = new TurnOnCommand(television);
Command changeChannelCommand = new ChangeChannelCommand(television);
Command adjustVolumeCommand = new AdjustVolumeCommand(television);

RemoteControl remoteControl = new RemoteControl();

remoteControl.setCommand(turnOnCommand);
remoteControl.pressButton();

remoteControl.setCommand(changeChannelCommand);
remoteControl.pressButton();

remoteControl.setCommand(adjustVolumeCommand);
remoteControl.pressButton();
}
}

這個示例中，我們將不同的操作（打開電視、切換頻道、調整音量）封裝成了命令對象，通過遙控器執行這些命令，而不需要直接調用接收者的方法。

宏命令

宏命令是一種命令模式的擴展，它允許您將多個命令組合成一個更大的命令。宏命令本身也是一個命令，可以執行一系列子命令。這對于執行復雜的操作或者創建多級撤銷機制非常有用。

讓我們通過一個示例來了解宏命令。假設我們有一個文本編輯器，需要實現一個宏命令來執行以下操作：

打開文件
編輯文件
保存文件

首先，我們定義一個宏命令接口 macroCommand，它包含了 add 和 execute 方法：

public interface MacroCommand {
void add(Command command);
void execute();
}

接下來，我們創建一個具體的宏命令類 TextEditorMacro，它可以添加和執行多個子命令：

public class TextEditorMacro implements MacroCommand {
private List<Command> commands = new ArrayList<>();

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

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

然后，我們可以創建多個子命令，例如 OpenFileCommand、EditFileCommand 和 SaveFileCommand，它們分別執行打開、編輯和保存文件的操作。

最后，我們可以使用宏命令將這些子命令組合成一個宏命令：

public class Client {
public static void main(String[] args) {
OpenFileCommand openFile = new OpenFileCommand();
EditFileCommand editFile = new EditFileCommand();
SaveFileCommand saveFile = new SaveFileCommand();

TextEditorMacro macro = new TextEditorMacro();
macro.add(openFile);
macro.add(editFile);
macro.add(saveFile);

// 執行宏命令，依次執行子命令
macro.execute();
}
}

這樣，我們就實現了一個宏命令，可以一次性執行多個子命令，從而打開、編輯和保存文件。

撤銷和重做

命令模式還支持撤銷和重做操作。

為了實現撤銷，我們需要在命令對象中保存執行前的狀態，并提供一個 undo 方法來恢復到之前的狀態。

讓我們通過一個簡單的示例來演示撤銷和重做。假設我們有一個文本編輯器，可以執行添加文本、刪除文本和撤銷操作。

首先，我們定義一個命令接口 Command，包括了 execute 和 undo 方法：

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

接下來，我們創建具體的命令類，例如 AddTextCommand 和 DeleteTextCommand，它們分別執行添加文本和刪除文本的操作，并實現了 undo 方法來撤銷操作。

public class AddTextCommand implements Command {
private TextEditor textEditor;
private String addedText;

public AddTextCommand(TextEditor textEditor, String addedText) {
this.textEditor = textEditor;
this.addedText = addedText;
}

public void execute() {
textEditor.addText(addedText);
}

public void undo() {
textEditor.deleteText(addedText);
}
}

// 類似地實現 DeleteTextCommand

然后，我們創建接收者類 TextEditor，它包含了實際的文本編輯邏輯，包括添加文本、刪除文本和顯示文本。

public class TextEditor {
private StringBuilder text = new StringBuilder();

public void addText(String addedText) {
text.Append(addedText);
}

public void deleteText(String deletedText) {
int start = text.lastIndexOf(deletedText);
if (start != -1) {
text.delete(start, start + deletedText.length());
}
}

public void displayText() {
System.out.println(text.toString());
}
}

最后，我們可以創建一個客戶端來測試撤銷和重做操作：

public class Client {
public static void main(String[] args) {
TextEditor textEditor = new TextEditor();

Command addCommand1 = new AddTextCommand(textEditor, "Hello, ");
Command addCommand2 = new AddTextCommand(textEditor, "Design Patterns!");
Command deleteCommand = new DeleteTextCommand(textEditor, "Patterns!");

// 執行添加和刪除操作
addCommand1.execute();
addCommand2.execute();
deleteCommand.execute();

// 顯示當前文本
textEditor.displayText(); // 輸出: Hello, Design!

// 撤銷刪除操作
deleteCommand.undo();

// 顯示當前文本
textEditor.displayText(); // 輸出: Hello, Design Patterns!
}
}

通過上述代碼，我們實現了撤銷和重做操作，可以在執行操作后撤銷到之前的狀態，然后再重做。這在需要保留操作歷史的應用程序中非常有用。