java实现建造者模式（Builder Pattern）

下面我就详细讲解一下“Java实现建造者模式（Builder Pattern）”的完整攻略。

什么是建造者模式？

建造者模式是一种对象创建型设计模式，它允许你创建不同风格的对象，同时避免构造器污染问题。在该模式中，我们将构造过程分步进行，使得在创建对象时能够更加灵活地控制每个构造步骤，从而创建不同类型的对象。

建造者模式的角色

建造者模式中有以下几个角色：

1. Product

Product 表示要生成的复杂对象，包含多个子部件。

2. Builder

Builder 定义抽象接口，规范了将部件装配到产品中的方法。

3. ConcreteBuilder

ConcreteBuilder 实现 Builder 接口，定义将具体部件装配到产品中的方法。

4. Director

Director 负责按照一定的顺序调用 Builder 中的方法来装配部件，然后构建复杂对象。

Java实现建造者模式示例

下面我们来看一下建造者模式的代码示例。

示例一：建造一个电脑

// Product
public class Computer {
    private String cpu;
    private String memory;
    private String hardDisk;
    private String display;

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getDisplay() {
        return display;
    }

    public void setDisplay(String display) {
        this.display = display;
    }
}

// Builder
public interface ComputerBuilder {
    void setCpu();

    void setMemory();

    void setHardDisk();

    void setDisplay();

    Computer getProduct();
}

// ConcreteBuilder
public class StandardComputerBuilder implements ComputerBuilder {
    Computer computer = new Computer();

    @Override
    public void setCpu() {
        computer.setCpu("Intel Core i5-8300H");
    }

    @Override
    public void setMemory() {
        computer.setMemory("8GB DDR4 2666MHz");
    }

    @Override
    public void setHardDisk() {
        computer.setHardDisk("256GB SSD");
    }

    @Override
    public void setDisplay() {
        computer.setDisplay("15.6 inch FHD (1920 x 1080)");
    }

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

// Director
public class ComputerDirector {
    private ComputerBuilder computerBuilder;

    public ComputerDirector(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public void buildComputer() {
        computerBuilder.setCpu();
        computerBuilder.setMemory();
        computerBuilder.setHardDisk();
        computerBuilder.setDisplay();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        ComputerBuilder builder = new StandardComputerBuilder();
        ComputerDirector director = new ComputerDirector(builder);
        director.buildComputer();
        Computer computer = builder.getProduct();
        System.out.println(computer.getCpu());
        System.out.println(computer.getMemory());
        System.out.println(computer.getHardDisk());
        System.out.println(computer.getDisplay());
    }
}

在这个示例中，我们为电脑创建了一个 Product 类，表示要生成的电脑，包含了 cpu、memory、hardDisk 和 display 四个属性。然后创建了一个 Builder 接口，定义了将各个部件装配到电脑中的方法。接着创建了一个 ConcreteBuilder 类 StandardComputerBuilder，它实现了 Builder 接口，定义了将具体部件装配到电脑中的方法。然后创建了一个 Director 类 ComputerDirector，它负责按照一定的顺序调用 Builder 中的方法来装配部件，然后构建电脑。最后在客户端创建了一个 StandardComputerBuilder 对象，并将其传递给 ComputerDirector，调用 buildComputer 方法构建电脑，然后获取产品的实例。

示例二：建造一个鸟的巢

// Product
public class BirdNest {
    private int size;
    private String material;
    private String location;

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public String getMaterial() {
        return material;
    }

    public void setMaterial(String material) {
        this.material = material;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }
}

// Builder
public interface BirdNestBuilder {
    void setSize();

    void setMaterial();

    void setLocation();

    BirdNest getProduct();
}

// ConcreteBuilder
public class WeaveBirdNestBuilder implements BirdNestBuilder {
    BirdNest nest = new BirdNest();

    @Override
    public void setSize() {
        nest.setSize(10);
    }

    @Override
    public void setMaterial() {
        nest.setMaterial("straw and twigs");
    }

    @Override
    public void setLocation() {
        nest.setLocation("in a tree");
    }

    @Override
    public BirdNest getProduct() {
        return nest;
    }
}

// Director
public class BirdNestDirector {
    private BirdNestBuilder nestBuilder;

    public BirdNestDirector(BirdNestBuilder nestBuilder) {
        this.nestBuilder = nestBuilder;
    }

    public void buildNest() {
        nestBuilder.setSize();
        nestBuilder.setMaterial();
        nestBuilder.setLocation();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        BirdNestBuilder builder = new WeaveBirdNestBuilder();
        BirdNestDirector director = new BirdNestDirector(builder);
        director.buildNest();
        BirdNest nest = builder.getProduct();
        System.out.println(nest.getMaterial());
        System.out.println(nest.getLocation());
        System.out.println(nest.getSize());
    }
}

在这个示例中，我们为鸟的巢创建了一个 Product 类，表示要生成的巢，包含了 size、material 和 location 三个属性。然后创建了一个 Builder 接口，定义了将各个部件装配到巢中的方法。接着创建了一个 ConcreteBuilder 类 WeaveBirdNestBuilder，它实现了 Builder 接口，定义了将具体部件装配到巢中的方法。然后创建了一个 Director 类 BirdNestDirector，它负责按照一定的顺序调用 Builder 中的方法来装配部件，然后构建巢。最后在客户端创建了一个 WeaveBirdNestBuilder 对象，并将其传递给 BirdNestDirector，调用 buildNest 方法构建巢，然后获取产品的实例。

建造者模式的优点

1. 建造者模式将创建对象的过程分步进行，可以更加灵活地控制每个构造步骤，从而创建不同类型的对象。
2. 建造者模式可以避免构造器污染问题，提高代码的可读性和可维护性。
3. 建造者模式可以将复杂对象的创建过程独立出来，方便后期修改和维护。

总结

这就是 Java 实现建造者模式的完整攻略，建造者模式是一种非常实用的设计模式，能够有效地提高代码的可读性和可维护性。可以根据具体的需求选择不同的 Builder 构造器，从而得到不同类型的对象。