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

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

五、建造者模式：建造者模式如何解决复杂对象的构建问题？

建造者模式（Builder Pattern）是一种对象创建型设计模式，用于解决复杂对象的构建问题。它允许通过逐步构建一个复杂对象来分离对象的构建过程和表示，使得相同的构建过程可以创建不同的表示。

建造者模式的主要角色：

1. 建造者（Builder）：定义创建复杂对象的接口。
2. 具体建造者（ConcreteBuilder）：实现建造者接口，构建并提供最终的对象。
3. 导演者（Director）：负责使用建造者来创建对象的步骤。
4. 产品（Product）：复杂对象的抽象类，定义了产品的属性和行为。
5. 具体产品（ConcreteProduct）：实现产品接口的具体类，是构建过程产生的最终对象。

建造者模式如何解决复杂对象的构建问题：

1. 分离构建和表示：建造者模式将对象的构建过程和最终表示分离开来，使得构建过程可以在不影响表示的情况下独立变化。

2. 控制复杂性：通过逐步构建对象，可以控制复杂对象的构建过程，避免使用大量的参数来创建对象。

3. 增加灵活性：建造者模式允许通过相同的构建过程来创建不同的产品，增加了对象构建的灵活性。

4. 避免使用复杂的构造函数：在没有建造者模式的情况下，创建复杂对象可能需要一个包含多个参数的构造函数，这使得代码难以理解和维护。

5. 支持不变的对象：建造者模式可以创建不可变对象，因为对象的构建过程是逐步进行的，一旦构建完成，对象的状态就固定了。

实际应用场景：

1. 汽车制造：在汽车制造过程中，可以使用建造者模式来逐步添加汽车的各个部件，如引擎、轮胎等。

2. 文档编辑：在文档编辑软件中，可以使用建造者模式来逐步构建文档的不同部分，如标题、段落、图片等。

3. 复杂图形界面的构建：在图形界面的构建过程中，可以使用建造者模式来逐步添加组件，如按钮、文本框等。

示例代码（Java）：

// 产品接口
interface Product {
    void show();
}

// 具体产品
class Computer implements Product {
    private String cpu;
    private String ram;
    private String hdd;

    // 省略构造函数、getter和setter

    @Override
    public void show() {
        System.out.println("CPU: " + cpu + ", RAM: " + ram + ", HDD: " + hdd);
    }
}

// 建造者接口
interface Builder {
    void setCPU(String cpu);
    void setRAM(String ram);
    void setHDD(String hdd);
    Product getProduct();
}

// 具体建造者
class ComputerBuilder implements Builder {
    private Computer computer = new Computer();

    @Override
    public void setCPU(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void setRAM(String ram) {
        computer.setRam(ram);
    }

    @Override
    public void setHDD(String hdd) {
        computer.setHdd(hdd);
    }

    @Override
    public Product getProduct() {
        return computer;
    }
}

// 导演者
class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Product construct() {
        builder.setCPU("i7");
        builder.setRAM("16GB");
        builder.setHDD("1TB");
        return builder.getProduct();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Director director = new Director(new ComputerBuilder());
        Product product = director.construct();
        product.show();
    }
}

在这个示例中，Computer是具体产品，Builder是建造者接口，ComputerBuilder是具体建造者，实现了建造者接口并构建Computer对象。Director是导演者，负责调用建造者的方法来构建产品。客户端代码演示了如何使用建造者模式来创建一个Computer对象。通过建造者模式，我们可以清晰地看到对象的构建过程，并且可以轻松地扩展或修改构建过程。

六、原型模式：请描述原型模式的工作原理及其适用场景。

原型模式（Prototype Pattern）是一种创建型设计模式，它使用原型实例指定创建对象的种类，并通过复制这些原型来创建新的对象。这种模式允许一个类的实例创建一个或多个它的克隆，而不需要知道这些实例的类是如何构建的。

原型模式的工作原理：

1. 定义克隆接口：定义一个克隆接口，通常是一个clone()方法，用于创建当前对象的一个副本。

2. 实现克隆接口：所有可克隆的类都实现这个克隆接口，以提供复制自身的能力。

3. 使用原型管理类（可选）：可以创建一个原型管理类来管理所有的原型对象，允许增加、删除、选择原型。

4. 复制对象：当需要创建一个新的对象时，不是通过构造函数，而是通过选择一个原型对象，并复制它来创建新对象。

5. 深拷贝与浅拷贝：复制可以分为浅拷贝和深拷贝。浅拷贝只复制对象本身，而深拷贝会递归地复制对象的所有成员变量，包括引用类型成员。

原型模式的适用场景：

1. 创建新对象成本较大：当对象的创建过程复杂，或者构造成本较高时，使用原型模式可以避免重复的创建过程。

2. 需要通过实例化创建对象：在某些情况下，可能需要通过实例化一个已有的对象来创建新对象，而不是从头开始构造。

3. 动态加载和卸载对象：在需要动态加载和卸载对象的场景中，原型模式可以方便地实现对象的复制和删除。

4. 实现复杂对象的复制：对于包含复杂引用结构的对象，原型模式可以方便地实现对象的复制。

5. 避免使用复杂的构造函数：当对象的构造函数过于复杂或包含多个参数时，使用原型模式可以简化对象的创建过程。

6. 实现对象的按需复制：在某些情况下，可能需要根据当前对象的状态来创建新对象，原型模式可以方便地实现这一点。

示例代码（Java）：

// 克隆接口
interface Prototype {
    Prototype clone();
}

// 具体原型类
class Sheep implements Prototype {
    private String name;

    public Sheep(String name) {
        this.name = name;
    }

    @Override
    public Prototype clone() {
        try {
            return (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    public String getName() {
        return name;
    }
}

// 客户端代码
public class PrototypePatternDemo {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("喜羊羊");
        Sheep clonedSheep = sheep.clone();
        System.out.println(sheep.getName());
        System.out.println(clonedSheep.getName());
    }
}

在这个示例中，Prototype是克隆接口，Sheep是具体原型类，实现了Prototype接口的clone()方法。客户端代码演示了如何使用原型模式来复制一个Sheep对象。通过实现clone()方法，Sheep类可以创建自己的副本，而不需要使用构造函数。

原型模式是一种强大的模式，可以在多种场景下简化对象的创建过程，提高代码的灵活性和可维护性。