整理好了！2024年最常见 20 道设计模式面试题（七）

上一篇地址：整理好了！2024年最常见 20 道设计模式面试题（六）-CSDN博客

十三、请解释桥接模式，并给出一个使用场景。

桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与其实现部分分离，使它们可以独立地变化。这种模式主要用于解决当一个类存在多个维度的变化时，如何避免使用多重继承带来的复杂性问题。

桥接模式的组成部分：

1. 抽象（Abstraction）：定义了客户端使用的接口，它维持了一个指向实现化角色的引用。
2. 扩展抽象（Refined Abstraction）：扩展了抽象类，添加了更多的业务方法。
3. 实现化角色（Implementor）：定义了实现化对象的接口，不依赖于抽象角色。
4. 具体实现化（Concrete Implementor）：实现了实现化角色定义的接口，具体实现了某种业务。

桥接模式的工作原理：

• 抽象类定义了业务接口，并且包含一个实现化角色的引用。
• 扩展抽象类继承自抽象类，增加了一些业务方法，这些方法可能会调用实现化角色的方法。
• 实现化角色定义了一组接口，这些接口可以被不同的具体实现化类实现。
• 具体实现化类实现了实现化角色定义的接口，提供了具体的实现。

使用场景：

假设我们正在开发一个图形绘制程序，该程序可以绘制多种形状，并且可以以不同的颜色绘制。这里的形状和颜色是两个变化的维度，使用桥接模式可以很好地解决这个问题。

• 抽象（Shape）：定义了绘制形状的接口。
• 扩展抽象（ColoredShape）：扩展了形状，增加了颜色属性和绘制带颜色的形状的方法。
• 实现化角色（DrawAPI）：定义了绘制接口，不依赖于形状。
• 具体实现化（RedPen, BluePen）：实现了DrawAPI接口，分别提供了红色和蓝色的绘制实现。

代码示例（伪代码）：

// 抽象形状类
class Shape {
    protected DrawAPI drawAPI;

    public Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

// 扩展抽象类，带颜色的形状
class ColoredShape extends Shape {
    private String color;

    public ColoredShape(DrawAPI drawAPI, String color) {
        super(drawAPI);
        this.color = color;
    }

    public void draw() {
        drawAPI.draw(color);
    }
}

// 绘制接口
interface DrawAPI {
    void draw(String color);
}

// 具体实现化类：红色笔
class RedPen implements DrawAPI {
    public void draw(String color) {
        System.out.println("Drawing with " + color + " pen.");
    }
}

// 具体实现化类：蓝色笔
class BluePen implements DrawAPI {
    public void draw(String color) {
        System.out.println("Drawing with " + color + " pen.");
    }
}

// 客户端代码
Shape shape = new ColoredShape(new RedPen(), "Red");
shape.draw(); // 输出: Drawing with Red pen.

shape = new ColoredShape(new BluePen(), "Blue");
shape.draw(); // 输出: Drawing with Blue pen.

通过桥接模式，我们可以轻松地添加新的形状或颜色，而不需要修改现有的类结构。这提高了系统的可扩展性和可维护性。

十四、责任链模式是如何工作的？它在哪些情况下特别有用？

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者对象的链进行传递，直到有一个处理者对象能够处理这个请求为止。这种模式可以避免请求的发送者和接收者之间的耦合关系，让多个对象都有可能接收请求，从而避免它们之间的耦合。

责任链模式的组成部分：

1. 处理者（Handler）：定义了一个处理请求的接口，所有具体处理者都实现这个接口。
2. 具体处理者（Concrete Handler）：实现处理者接口，并对请求进行处理。如果能够处理请求，则处理之；否则，将请求传递给链中的下一个处理者。
3. 请求（Request）：需要被处理者处理的请求。

责任链模式的工作原理：

1. 每个具体处理者对象都有权决定是否处理这个请求。
2. 一个具体处理者对象接收到请求后，如果能够处理这个请求，则处理它；否则，将请求传递给链中的下一个处理者对象。
3. 请求沿着责任链一直传递，直到有一个处理者对象能够处理这个请求为止，或者直到链的末端都没有处理者处理这个请求。

使用场景：

责任链模式特别适用于以下情况：

• 当多个对象可以处理同一个请求，但具体由哪个对象处理应由程序运行时刻自动确定。
• 当你想将请求的处理者对象集合起来，让它们有序地、链式地处理请求，而不需要显式地指定哪个处理者对象处理它。
• 当需要动态地增加或删除责任链中的处理者时。

代码示例（伪代码）：

// 处理者接口
interface Handler {
    void setNext(Handler handler);
    void handleRequest(Request request);
}

// 具体处理者A
class ConcreteHandlerA implements Handler {
    private Handler next;

    public void setNext(Handler handler) {
        this.next = handler;
    }

    public void handleRequest(Request request) {
        if (request.getType() == "A") {
            System.out.println("Handled by A");
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}

// 具体处理者B
class ConcreteHandlerB implements Handler {
    private Handler next;

    public void setNext(Handler handler) {
        this.next = handler;
    }

    public void handleRequest(Request request) {
        if (request.getType() == "B") {
            System.out.println("Handled by B");
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}

// 请求对象
class Request {
    private String type;

    public String getType() {
        return type;
    }
}

// 客户端代码
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
handlerA.setNext(handlerB); // 构建责任链

Request request1 = new Request();
request1.setType("A");
handlerA.handleRequest(request1); // 输出: Handled by A

Request request2 = new Request();
request2.setType("B");
handlerA.handleRequest(request2); // 输出: Handled by B

在这个示例中，我们创建了两个具体处理者ConcreteHandlerA和ConcreteHandlerB，它们分别处理类型为"A"和"B"的请求。通过设置setNext方法，我们构建了一个责任链。当请求被发送到handlerA时，它首先检查自己是否可以处理，如果可以，则处理之；否则，将请求传递给handlerB。

责任链模式可以有效地将请求的处理逻辑从请求的发送者中解耦出来，使得系统更加灵活和易于扩展。