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

建造者模式的4个角色：

Product产品类：通常是实现了模版方法模式，有模版方法和基本方法。

Builder抽象建造者：规范产品的组建，一般是由子类实现。

ConcreteBuilder具体建造者：实现抽象建造者定义的所有方法，并且返回一个组建好的对象。

Director导演类：负责安排已有模块的顺序，然后告诉Builder开始构建。

package com.juno.BuilderPattern;import java.util.ArrayList;public abstract class Product {public final static int MSG_OPERATE_1 = 1;public final static int MSG_OPERATE_2 = 2;private ArrayList<Integer> sequence = new ArrayList<Integer>();protected abstract void operate1();protected abstract void operate2();public final void doSomething() {if(sequence.size() == 0) {return;}for(int msg : sequence) {if (msg == MSG_OPERATE_1) {operate1();} else if (msg == MSG_OPERATE_2) {operate2();}}} public final void setSequence(ArrayList<Integer> sequence) {this.sequence = sequence;}
}

package com.juno.BuilderPattern;public class ConcreteProductA extends Product {@Overrideprotected void operate1() {System.out.println("ProductA use MSG_OPERATE_1 operate1~~");}@Overrideprotected void operate2() {System.out.println("ProductA use MSG_OPERATE_2 operate2~~");}}

package com.juno.BuilderPattern;public class ConcreteProductB extends Product {@Overrideprotected void operate1() {System.out.println("ProductB use MSG_OPERATE_1 operate1~~");}@Overrideprotected void operate2() {System.out.println("ProductB use MSG_OPERATE_2 operate2~~");}}

package com.juno.BuilderPattern;import java.util.ArrayList;public abstract class Builder {public abstract void setPart(ArrayList<Integer> sequence);public abstract Product buildProduct();
}

package com.juno.BuilderPattern;import java.util.ArrayList;public class ConcreteBuilderA extends Builder {private ConcreteProductA productA = new ConcreteProductA();@Overridepublic void setPart(ArrayList<Integer> sequence) {this.productA.setSequence(sequence);}@Overridepublic ConcreteProductA buildProduct() {return this.productA;}}

package com.juno.BuilderPattern;import java.util.ArrayList;public class ConcreteBuilderB extends Builder {private ConcreteProductB productB = new ConcreteProductB();@Overridepublic void setPart(ArrayList<Integer> sequence) {this.productB.setSequence(sequence);}@Overridepublic ConcreteProductB buildProduct() {return this.productB;}}

package com.juno.BuilderPattern;import java.util.ArrayList;public class Director {private ArrayList<Integer> sequence = new ArrayList<Integer>();private ConcreteBuilderA productABuilder = new ConcreteBuilderA();private ConcreteBuilderB productBBuilder = new ConcreteBuilderB();public ConcreteProductA getProductA1() {sequence.clear();sequence.add(Product.MSG_OPERATE_1);sequence.add(Product.MSG_OPERATE_2);productABuilder.setPart(sequence);return productABuilder.buildProduct();}public ConcreteProductA getProductA2() {sequence.clear();sequence.add(Product.MSG_OPERATE_1);productABuilder.setPart(sequence);return productABuilder.buildProduct();}public ConcreteProductB getProductB1() {sequence.clear();sequence.add(Product.MSG_OPERATE_1);sequence.add(Product.MSG_OPERATE_2);productBBuilder.setPart(sequence);return productBBuilder.buildProduct();}public ConcreteProductB getProductB2() {sequence.clear();sequence.add(Product.MSG_OPERATE_2);productBBuilder.setPart(sequence);return productBBuilder.buildProduct();}
}

package com.juno.BuilderPattern;public class Client {public static void main(String[] args) {Director director = new Director();System.out.println("== ProductA1 ==");director.getProductA1().doSomething();System.out.println("== ProductA2 ==");director.getProductA2().doSomething();System.out.println("== ProductB1 ==");director.getProductB1().doSomething();System.out.println("== ProductB2 ==");director.getProductB2().doSomething();}
}

打印：
== ProductA1 ==
ProductA use MSG_OPERATE_1 operate1~~
ProductA use MSG_OPERATE_2 operate2~~
== ProductA2 ==
ProductA use MSG_OPERATE_1 operate1~~
== ProductB1 ==
ProductB use MSG_OPERATE_1 operate1~~
ProductB use MSG_OPERATE_2 operate2~~
== ProductB2 ==
ProductB use MSG_OPERATE_2 operate2~~