设计模式——建造者

建造者角色：

分为抽象建造者、具体建造者

package designpattern.creation.builder;

public interface Builder {

    void buildPart1();
    void buildPart2();
    void buildPart3();
    void buildPartn();
    
    IProduct retrieveResult();
}

package designpattern.creation.builder;

public class ConcreteBuilder1 implements Builder {

    IProduct product;
    
    public ConcreteBuilder1() {
        product = new Product();
    }
    
    // 
    public void buildPart1() {
         // --- 此处的参数由具体的建造者决定，表示具体的建造过程，
        //这些对外界是不可知的！ —— 这既是建造者模式的真正含义！！！
        product.setPart1("part1");
        System.out.println("ConcreteBuilder.buildPart1()");
    }

    public void buildPart2() {
        product.setPart2("part2");
        System.out.println("ConcreteBuilder.buildPart2()");
    }

    public void buildPart3() {
        product.setPart3("part3");
        System.out.println("ConcreteBuilder.buildPart3()");
    }

    public void buildPartn() {
        product.setPartn("partn");
        System.out.println("ConcreteBuilder.buildPartn()");
    }

    public IProduct retrieveResult() {
        buildPart1();//可以吧参数放到这个位置传入？
        buildPart2();
        buildPart3();
        buildPartn();
        return product;
    }

}

package designpattern.creation.builder;

public class ConcreteBuilder2 implements Builder {

    IProduct product;
    
    public ConcreteBuilder2() {
        product = new Product();
    }
    
    // 
    public void buildPart1() {
         // --- 此处的参数由具体的建造者决定，表示具体的建造过程，
        //这些对外界是不可知的！ —— 这既是建造者模式的真正含义！！！
        product.setPart1("part1xx");
        System.out.println("ConcreteBuilder2.buildPart1()");
    }

    public void buildPart2() {
        product.setPart2("part2xx");
        System.out.println("ConcreteBuilder2.buildPart2()");
    }

    public void buildPart3() {
        product.setPart3("part3xx");
        System.out.println("ConcreteBuilder2.buildPart3()");
    }

    public void buildPartn() {
        product.setPartn("partnxx");
        System.out.println("ConcreteBuilder2.buildPartn()");
    }

    // 应该把buildPart1..n的建造过程放在这里吗？？还是应该放在Director里面呢？
    public IProduct retrieveResult() {
        buildPart1();//可以吧参数放到这个位置传入？
        buildPart2();
        buildPart3();
        buildPartn();
        return product;
    }

}

指导者角色：

package designpattern.creation.builder;


/**
 * 
 * Director 即相当于工厂的角色， 负责构建，或者说生产，具体产品
 * @author Administrator
 *
 */
public class Director {

    Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    
    // Director 负责指导建造产品！
    public IProduct build() {
//        builder.buildPart1();//可以吧参数放到这个位置传入？
//        builder.buildPart2();
//        builder.buildPart3();
//        builder.buildPartn();
        
        return builder.retrieveResult();
    }
}

产品角色：

package designpattern.creation.builder;

public interface IProduct {

    void setPart1(String part);
    void setPart2(String part);
    void setPart3(String part);
    void setPartn(String part);

    
    void use();
}

package designpattern.creation.builder;

public class Product implements IProduct {

    String part1;
    String part2;
    String part3;
    String partn;
    
    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 getPartn() {
        return partn;
    }
    public void setPartn(String partn) {
        this.partn = partn;
    }
    public void use() {
        // TODO Auto-generated method stub
        System.out.println("ProductA.use() :" + this.toString());
    }
    

    public void buildPart1() {
        this.part1 = "part1";
        System.out.println("ConcreteBuilder.buildPart1()");
    }

    public void buildPart2() {
        this.part1 = "part2";
        System.out.println("ConcreteBuilder.buildPart2()");
    }

    public void buildPart3() {
        this.part1 = "part3";
        System.out.println("ConcreteBuilder.buildPart3()");
    }

    public void buildPartn() {
        this.part1 = "partn";
        System.out.println("ConcreteBuilder.buildPartn()");
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.getPart1() + " " + this.getPart2() + " " + 
        this.getPart3() + " " + this.getPartn() + "";
    }
    
}

客户端：

package designpattern.creation.builder;


/**
 * 
如果你需要创建一个对象，这个对象很复杂：
    有很多部件组成，部件和部件之间可能存在（也可能不存在）一定的顺序和链接关系，而你又不想让客户知道这些对象内部细节（比如一道中药秘方，有哪些配料，如何调配，能让别人知道吗？-__-），
那么你可以选择Builder模式来创建这个对象。
 */
public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        IProduct product = new Director(new ConcreteBuilder1()).build();
        product.use();

        IProduct product2 = new Director(new ConcreteBuilder2()).build();
        product2.use();
    }

}

———— 感觉跟模板方法模式比较相像—— 如果把buildPart3看做带实现的模板方法