建造者模式

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

建造模式是对象的创建模式。建造模式可以将一个产品的内部表象（internal representation）与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。

使用范围

1. 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2. 当构造过程必须允许被构造的对象有不同表示时。

角色分配
在这样的设计模式中，有以下几个角色：

1. Builder：为创建一个产品对象的各个部件指定抽象接口。
2. ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
3. Director：构造一个使用Builder接口的对象，指导构建过程。
4. Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

代码例子

//创建Builder
public interface Builder {
    public void setPart1();
    public void setpart2();
    public void setPart3();
    public void setPart4();
    public Part getPart();
}
//再创建不同类型的ConcreteBuilder
public class BuilderPartOne implements Builder {
    private PartOne part;
    public BuilderPartOne(){
        part=new PartOne();
    }
    @Override
    public void setPart1() {
        part.setPart1("PartOne设置part1");
    }

    @Override
    public void setpart2() {
        part.setPart2("PartOne设置part2");
    }

    @Override
    public void setPart3() {
        part.setPart3("PartOne设置part3");
    }

    @Override
    public void setPart4() {
        part.setPart4("PartOne设置part4");
    }

    @Override
    public Part getPart() {
        return part;
    }
}
public class BuilderPartTwo implements Builder {
    private  PartTwo part;

    public BuilderPartTwo(){
        part=new PartTwo();
    }
    @Override
    public void setPart1() {
        part.setPart1("PartTwo设置part1");
    }

    @Override
    public void setpart2() {
        part.setPart2("PartTwo设置part2");
    }

    @Override
    public void setPart3() {
        part.setPart3("PartTwo设置part3");
    }

    @Override
    public void setPart4() {
        part.setPart4("PartTwo设置part4");
    }

    @Override
    public Part getPart() {
        return part;
    }
}

//再提供Director
public class PartDirector {
    public Part getPart(Builder builder){
        builder.setPart1();
        builder.setpart2();
        builder.setPart3();
        builder.setPart4();
        return builder.getPart();
    }
}
//Product
public class Part {
    private String part1;
    private String part2;
    private String part3;
    private String part4;

    @Override
    public String toString() {
        return "Part{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", 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;
    }
}

public class PartOne extends Part{
    public PartOne(){
        System.out.println("开始建造PartOne");
    }
}

public class PartTwo extends Part{
    public PartTwo(){
        System.out.println("开始建造PartTwo");
    }
}
//最后测试方法
public class Test {
    public static void main(String[] args) {
        PartDirector partDirector=new PartDirector();
        Part partone=partDirector.getPart(new BuilderPartOne());
        Part partTwo=partDirector.getPart(new BuilderPartTwo());
        System.out.println(partone);
        System.out.println(partTwo);
    }
}

打印的结果

扩展

建造者模式在使用过程中可以演化出多种形式：
如果具体的被建造对象只有一个的话，可以省略抽象的Builder和Director，让ConcreteBuilder自己扮演指导者和建造者双重角色，甚至ConcreteBuilder也可以放到Product里面实现.

只制造PartOne

public class PartBuilder {
    private PartOne part;
    public PartBuilder(){
        part=new PartOne();
    }

    public void setPart1(){
        part.setPart1("PartBuilder 设置 part1");
    }

    public void setPart2(){
        part.setPart2("PartBuilder 设置 part2");
    }

    public void setPart3(){
        part.setPart3("PartBuilder 设置 part3");
    }

    public void setPart4(){
        part.setPart4("PartBuilder 设置 part4");
    }

    public PartOne getPart(){
        setPart1();
        setPart2();
        setPart3();
        setPart4();
        return part;
    }
}
//测试
public class Test {
    public static void main(String[] args) {
       PartBuilder partBuilder=new PartBuilder();
        PartOne partOne = partBuilder .getPart();
        System.out.println(partOne);
    }
}

打印结果

从上面看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定