赶紧收藏！2024 年最常见 20道设计模式面试题（八）

上一篇地址：赶紧收藏！2024 年最常见 20道设计模式面试题（七）-CSDN博客

十五、模板方法模式是如何在父类中定义算法框架的？

模板方法模式通过在父类（通常是一个抽象类）中定义算法的骨架，同时允许子类实现或扩展某些步骤，来实现算法框架的定义。这种模式使得算法的结构保持不变，而某些特定步骤的行为可以被定制。以下是模板方法模式在父类中定义算法框架的详细步骤：

1. 定义模板方法：

   • 模板方法是在父类中定义的一个抽象方法，它规定了算法的总体流程。这个方法通常是一个最终方法（final），以确保子类不能改变算法的结构。

2. 调用基本方法：

   • 在模板方法中，父类调用一个或多个基本方法来实现算法的特定步骤。这些基本方法可以是抽象的，也可以是具体的。

3. 定义钩子方法（可选）：

   • 钩子方法是在父类中定义的，可以被子类覆盖的方法。它们通常在模板方法中被调用，允许子类在算法的执行过程中插入自己的行为。

4. 实现或扩展基本方法：

   • 父类可以提供一些基本方法的默认实现，这些方法可以被子类重写以提供特定的行为。

5. 抽象方法：

   • 对于那些需要由子类实现的步骤，父类中定义为抽象方法，子类必须提供这些方法的具体实现。

6. 确保算法的一致性：

   • 父类通过模板方法控制算法的执行流程，确保算法的一致性，即使子类改变了某些步骤的行为。

代码示例（伪代码）：

// 抽象类，定义算法框架
abstract class Game {
    // 模板方法，定义算法骨架
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }

    // 抽象方法，由子类实现
    protected abstract void initialize();

    // 钩子方法，可以被子类覆盖
    protected void startPlay() {
        // 默认行为
    }

    // 钩子方法，可以被子类覆盖
    protected void endPlay() {
        // 默认行为
    }
}

// 具体类：实现算法的特定步骤
class SoccerGame extends Game {
    @Override
    protected void initialize() {
        // 足球游戏的初始化
    }

    @Override
    protected void startPlay() {
        // 足球游戏的开始逻辑
    }

    @Override
    protected void endPlay() {
        // 足球游戏的结束逻辑
    }
}

// 客户端代码
Game game = new SoccerGame();
game.play(); // 执行足球游戏的算法流程

在这个示例中，Game 类是一个抽象类，它定义了 play 方法作为模板方法，该方法调用了 initialize、startPlay 和 endPlay 这三个基本方法，构成了一个游戏的算法框架。SoccerGame 类继承自 Game 类，并提供了 initialize、startPlay 和 endPlay 方法的具体实现，从而定制了足球游戏的算法步骤。通过这种方式，模板方法模式确保了算法的一致性，同时允许子类定制特定的行为。

十六、命令模式如何实现请求的封装和解耦？

命令模式（Command Pattern）是一种行为设计模式，它将一个请求或操作封装为一个对象。这种模式允许用户使用不同的请求、队列或日志请求来参数化其他对象，同时支持可撤销的操作。命令模式通过以下方式实现请求的封装和解耦：

命令模式的组成部分：

1. 命令接口（Command）：定义了执行操作的接口。
2. 具体命令（Concrete Command）：实现命令接口，对应于具体请求或操作。
3. 调用者（Invoker）：要求该命令执行这个请求。
4. 接收者（Receiver）：知道如何实施与执行一个请求相关的操作。

命令模式如何实现请求的封装：

1. 封装请求：命令接口定义了执行操作的方法，具体命令类实现这个接口，将请求封装为一个对象。这意味着请求的详细信息和执行逻辑都被包含在具体命令对象中。

2. 参数化调用者：调用者通过命令对象来执行请求，而不是直接调用接收者的方法。这样，调用者不需要知道接收者的具体实现，只需要知道命令对象。

3. 使用命令队列：命令对象可以被存储在队列中，允许系统在不同时间执行请求，实现请求的排队和调度。

命令模式如何实现请求的解耦：

1. 解耦调用者和接收者：调用者通过命令对象来间接调用接收者的方法，不需要直接与接收者交互。这样，调用者和接收者之间的耦合度降低。

2. 扩展性：当需要添加新的请求类型时，只需添加一个新的具体命令类，而不需要修改现有的调用者或接收者类。这符合开闭原则（对扩展开放，对修改封闭）。

3. 撤销操作：命令模式可以很容易地实现撤销操作。通过维护一个命令的历史列表，可以创建一个撤销命令来撤销之前执行的命令。

4. 日志记录：命令对象可以被用来记录请求的日志，便于后续的审计或调试。

代码示例（伪代码）：

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

// 接收者
class Receiver {
    public void action() {
        // 接收者执行的操作
    }
}

// 具体命令
class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    public void execute() {
        receiver.action();
    }
}

// 调用者
class Invoker {
    private Command command;

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

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

// 客户端代码
Receiver receiver = new Receiver();
Command command = new ConcreteCommand(receiver);
Invoker invoker = new Invoker();

invoker.setCommand(command);
invoker.trigger(); // 执行请求

在这个示例中，ConcreteCommand 类是一个具体命令，它封装了对 Receiver 类的 action 方法的调用。Invoker 类作为调用者，通过 setCommand 方法设置要执行的命令，并通过 trigger 方法执行这个命令。这样，调用者和接收者之间的耦合被命令对象解耦，同时请求被封装在命令对象中，可以灵活地进行操作，如排队、撤销等。