Java设计模式之建造者模式

• Java设计模式之建造者模式
• 前言
• 一、建造者模式
• 二、使用场景
• 三、使用
• • 1. 产品类
  • 2. 抽象建造者
  • 3. 具体建造者
  • 4. 指挥者
  • 5. 客户端
• 总结
• • 1. 优点
  • 2. 缺点
  • 3. 建造者模式和工厂模式的区别

1. 掌握建造者模式的应用场景
2. 掌握建造者模式的基本写法

• 建造者模式（Builder Pattern）是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
• 用户只需指定需要建造的类型就可以获得对象，建造过程及细节不需要了解。

• 适用于创建对象需要很多步骤，但是步骤的顺序不一定固定。
• 一个对象有非常复杂的内部结构（很多属性）。
• 把复杂对象的创建和使用分离。

public class Product {
    private String partA;

    private String partB;

    private String partC;

    public String getPartA() {
        return partA;
    }

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

    public String getPartB() {
        return partB;
    }

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

    public String getPartC() {
        return partC;
    }

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

public abstract class Builder {
    protected Product product = new Product();

    public abstract void buildPartA(String partA);

    public abstract void buildPartB(String partB);

    public abstract void buildPartC(String partC);

    public Product build() {
        return product;
    }
}

public class ConcreteBuilder extends Builder {
    @Override
    public void buildPartA(String partA) {
        product.setPartA(partA);
    }

    @Override
    public void buildPartB(String partB) {
        product.setPartB(partB);
    }

    @Override
    public void buildPartC(String partC) {
        product.setPartC(partC);
    }
}

public class Director {
    private Builder builder;

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

    public Product construct() {
        builder.buildPartA("A");
        builder.buildPartB("B");
        builder.buildPartC("C");
        return builder.build();
    }
}

public class Client {
    public static void main(String[] args) {
        Director director = new Director(new ConcreteBuilder());
        Product product = director.construct();
        System.out.println(product);
    }
}

• 封装性好，创建和使用分离
• 扩展性好，建造者类之间独立、一定程度上解耦

• 产生多余的Builder对象
• 产品内部发生变化，建造者都要修改，成本较大

• 建造者模式更加注重方法的调用顺序，工厂模式注重于创建对象。
• 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的不见组成，工厂模式创建出来的都一样。
• 关注点：工厂模式只需要把对象创建出来就可以了，而建造者模式中不仅要创建出这个对象，还要知道这个对象由哪些部件组成。
• 建造者模式根据建造过程中的顺序不一样，最终的对象部件组成也不一样。