原型模式与建造者模式详解

原型模式与建造者模式是软件设计模式中的两种常见创建型模式，它们都用于创建对象，但在实现方式和应用场景上有所不同。本文将详细介绍原型模式与建造者模式，并给出相应的代码示例。

一、原型模式
原型模式通过复制现有对象来创建新的对象，避免了通过构造函数创建新对象的开销，同时也避免了创建大量相似对象时的重复初始化操作。原型模式基于对象的克隆来实现对象的创建，它需要实现一个可以复制自身的方法。原型模式可以分为浅克隆和深克隆两种方式：

• 浅克隆：仅复制对象的基本数据类型属性，对于引用类型属性，则仍然共享同一个引用。
• 深克隆：不仅复制对象的基本数据类型属性，还复制引用类型属性，使得新对象和原对象的引用类型属性互不影响。

下面是一个简单的使用原型模式的示例代码：

// 定义原型接口
public interface Prototype {
    Prototype clone();
}

// 实现原型接口的具体类
public class ConcretePrototype implements Prototype {
    private int number;

    public void setNumber(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    @Override
    public Prototype clone() {
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setNumber(this.number);
        return prototype;
    }
}

// 测试原型模式
public class PrototypeTest {
    public static void main(String[] args) {
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setNumber(10);

        // 克隆原型对象
        ConcretePrototype clonedPrototype = (ConcretePrototype) prototype.clone();
        System.out.println("原型的number属性值：" + prototype.getNumber());
        System.out.println("克隆对象的number属性值：" + clonedPrototype.getNumber());
    }
}

二、建造者模式
建造者模式将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式通过一步一步地构造复杂对象，最终返回完整的对象。它适用于构建复杂对象，且构建过程需要多个步骤的情况。建造者模式包含以下几个角色：

• 产品（Product）：要构建的复杂对象。
• 抽象建造者（Builder）：定义了构建复杂对象各个部分的抽象方法。
• 具体建造者（Concrete Builder）：实现了抽象建造者的方法，负责具体的构建过程。
• 指挥者（Director）：负责组织构建过程，按照特定顺序调用建造者的方法来构建对象。

下面是一个简单的使用建造者模式的示例代码：

// 产品类
public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    public void show() {
        System.out.println("Product: " + partA + " " + partB + " " + partC);
    }
}

// 抽象建造者
public abstract class Builder {
    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    public abstract Product getResult();
}

// 具体建造者
public class ConcreteBuilder extends Builder {
    private Product product;

    public ConcreteBuilder() {
        product = new Product();
    }

    @Override
    public void buildPartA() {
        product.setPartA("PartA");
    }

    @Override
    public void buildPartB() {
        product.setPartB("PartB");
    }

    @Override
    public void buildPartC() {
        product.setPartC("PartC");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

// 指挥者
public class Director {
    public void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

// 测试建造者模式
public class BuilderTest {
    public static void main(String[] args) {
        Director director = new Director();
        ConcreteBuilder builder = new ConcreteBuilder();

        // 构建产品
        director.construct(builder);
        Product product = builder.getResult();

        // 展示产品
        product.show();
    }
}

以上代码分别展示了原型模式和建造者模式的基本实现方式，并给出了代码示例。通过使用原型模式和建造者模式，我们能够更灵活地创建对象，提高了代码的可复用性和可维护性。