GOF23种设计模式面试之建造者模式

建造者模式

建造者模式（builder），属于创建型模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

用户只需指定需要建造的类型就可以得到对应对象，建造的细节及逻辑不需要知道。如果一个对象有复杂的内部结构，或者把复杂对象的创建和使用分离，就可以考虑该设计模式。

和工厂模式不同的是，建造者模式可以创造不同的复杂的产品，而工厂模式的生产的产品都是一样的。且建造者模式更注重零件的装配顺序。

JDK中的StringBuilder、StringBuffer就是使用了这种设计模式。

---

例子：

模拟安装PC，通过静态内部类ComputerBuilder来为Computer赋值：

静态内部类拥有相同的属性，在静态内部类中每次返回内部类的this，可以不停地进行链式调用。

最后执行build()方法，将ComputerBuilder的属性给Computer的构造方法，将各个属性赋值给Computer对应的属性，最后将这个Computer实例返回

public class Computer {

    private String cpu;
    private String graphicsCard;
    private String board;
    private String memory;
    private String power;

    public Computer(ComputerBuilder computerBuilder) {
        this.cpu = computerBuilder.cpu;
        this.graphicsCard = computerBuilder.graphicsCard;
        this.board = computerBuilder.board;
        this.memory = computerBuilder.memory;
        this.power = computerBuilder.power;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Computer{");
        sb.append("cpu='").append(cpu).append('\'');
        sb.append(", graphicsCard='").append(graphicsCard).append('\'');
        sb.append(", board='").append(board).append('\'');
        sb.append(", memory='").append(memory).append('\'');
        sb.append(", power='").append(power).append('\'');
        sb.append('}');
        return sb.toString();
    }
	//建造者模式的静态内部类 
    public static class ComputerBuilder{
        private String cpu;
        private String graphicsCard;
        private String board;
        private String memory;
        private String power;

        public ComputerBuilder buildCpu(String cpu){
            this.cpu = cpu;
            return this;
        }
        public ComputerBuilder buildGraphicsCard(String graphicsCard){
            this.graphicsCard = graphicsCard;
            return this;
        }
        public ComputerBuilder buildBoard(String board){
            this.board = board;
            return this;
        }
        public ComputerBuilder buildMemory(String memory){
            this.memory = memory;
            return this;
        }
        public ComputerBuilder buildPower(String power){
            this.power = power;
            return this;
        }
        public Computer build(){
            return new Computer(this);
        }
    }
}

应用模拟：

public class Client {
    public static void main(String[] args){
        Computer computer = new Computer.ComputerBuilder()
                            .buildCpu("I7-10700K")
                            .buildGraphicsCard("RTX3080")
                            .buildBoard("Z-490")
                            .buildMemory("DDR4-16G")
                            .buildPower("G750")
                            .build();
        System.out.println(computer);// Computer{cpu='I7-10700K'....}
    }
}

优点：

• 封装性好,创建和使用分离
• 建造类相互独立、扩展性好

缺点：

• 会产生多余的Builder对象
• 产品内部发生变化，建造者也需要变更，维护成本较大