设计模式-建造者模式

将一个复杂对象的创建与他的表示分离，使得同样的构建过程可以创建
不同的表示

模式的结构

建造者（Builder）模式的主要角色如下。

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

package com.tuling.designpattern.builder.v1;

/**
 */
public class BuilderTest {
    public static void main(String[] args) {
           ProductBuilder productBuilder=new DefaultProductBuilder();
           Director director=new Director( productBuilder );
           Product product=director.makeProduct( "part1", "part2", "part3", "part4" );
           System.out.println(product);
    }
}

interface ProductBuilder{

    void buildPart1(String part1 );
    void buildPart2(String part2 );
    void buildPart3(String part3 );
    void buildPart4(String part4 );
    Product build();
}

class DefaultProductBuilder implements ProductBuilder{

    private String part1;
    private String part2;
    private String part3;
    private String part4;
    @Override
    public void buildPart1(String part1) {
        this.part1=part1;
    }

    @Override
    public void buildPart2(String part2) {
        this.part2=part2;
    }

    @Override
    public void buildPart3(String part3) {
        this.part3=part3;
    }

    @Override
    public void buildPart4(String part4) {
        this.part4=part4;
    }

    @Override
    public Product build() {
        return new Product(part1, part2, part3, part4 );
    }
}

class Director{

    private ProductBuilder productBuilder;

    public Director(ProductBuilder productBuilder) {
        this.productBuilder=productBuilder;
    }

    public Product makeProduct(String part1, String part2, String part3, String part4){
        productBuilder.buildPart1( part1 );
        productBuilder.buildPart2( part2 );
        productBuilder.buildPart3( part3 );
        productBuilder.buildPart4( part4 );
        Product product=productBuilder.build();
        return product;

    }

}


class Product{
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    //  .....


    public Product(String part1, String part2, String part3, String part4) {
        this.part1=part1;
        this.part2=part2;
        this.part3=part3;
        this.part4=part4;
    }

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1=part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2=part2;
    }

    public String getPart3() {
        return part3;
    }

    public void setPart3(String part3) {
        this.part3=part3;
    }

    public String getPart4() {
        return part4;
    }

    public void setPart4(String part4) {
        this.part4=part4;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                '}';
    }
}

通过前面的学习，我们已经了解了建造者模式，那么它和工厂模式有什么区别呢？

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

建造者模式主要适用于以下应用场景：

• 相同的方法，不同的执行顺序，产生不同的结果。
• 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
• 产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。
• 初始化一个对象特别复杂，参数多，而且很多参数都具有默认值

参考博客：

建造者模式（Bulider模式）详解