Builder模式（创建类）

意图

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

---

适用性

1. 创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2. 创建的对象很复杂的时候（通常是由很多其他的对象组合而成）
3. 复杂对象的创建过程和这个对象的表示（展示）分离开来

---

类图

Director：是构造一个使用Builder接口的对象

Client创建Director对象，并用它所想要的Builder对象进行配置。

Director创建和装配对象过程

---

demo实现

package builder;
/**
 * design pattern in java
 * name:builder
 * 目的：利用builder模式创建两种汽车carA和carB
 * car=glass+wheel+engine
 * carA=AmericanGlass+JapaneseWheel+ChinaEngine
 * carB=JapaneseGlass+AmericanWheel+FranceEngine
 * author:blackphoenix
 * create date:2002-08-19
 * modifier:Anyuan Zhao
 * modify date:2011-02-16
 */

/**
 * 定义部件glass的抽象类Glass
 * 和两个具体类AmericanGlass、JapaneseGlass
 */
abstract class Glass{
}
class AmericanGlass extends Glass{
    public String toString(){
        return "/"American Glass/" ";
    }
}
class JapaneseGlass extends Glass{
    public String toString(){
        return "/"Japanese Glass/" ";
    }
}

/**
 * 定义部件wheel的抽象类Wheel
 * 和两个具体类AmericanWheel、JapaneseWheel
 */
abstract class Wheel{
}
class AmericanWheel extends Wheel{
    public String toString(){
        return "/"American Wheel/" ";
    }
}
class JapaneseWheel extends Wheel{
    public String toString(){
        return "/"Japanese Wheel/" ";
    }
}

/**
 * 定义部件engine的抽象类Engine
 * 和两个具体类ChineseEngine、FranceEngine
 */
abstract class Engine{
}
class ChineseEngine extends Engine{
    public String toString(){
        return "/"Chinese Engine/" ";
    }
}
class FranceEngine extends Engine{
    public String toString(){    
        return "/"France Engine/" ";
    }
}

/**
 * 定义产品类Car
 */
class Car{
    Glass glass;
    Wheel wheel;
    Engine engine;
}
/**
 * 定义抽象建造器接口Builder
 */

interface CarBuilder{
    public void buildGlass();
    public void buildWheel();
    public void buildEngine();
    public Car getProduct();
}

/**
 * 具体建造器类CarABuilder
 * CarA=AmericanGlass+JapaneseWheel+ChineseEngine
 */
class CarABuilder implements CarBuilder{
    private Car product=null;
    public CarABuilder(){
        product=new Car();
    }
    /**
     * 将建造部件的工作封装在getProduct()操作中,主要是为了向客户隐藏实现细节
     * 这样，具体建造类同时又起到了一个director的作用
     */
    @Override
    public void buildEngine() {
        // TODO Auto-generated method stub
        product.engine=new ChineseEngine();
    }
    @Override
    public void buildGlass() {
        // TODO Auto-generated method stub
        product.glass=new AmericanGlass();
    }
    @Override
    public void buildWheel() {
        // TODO Auto-generated method stub
        product.wheel=new JapaneseWheel();
    }
    @Override
    public Car getProduct() {
        // TODO Auto-generated method stub
        buildGlass();
        buildWheel();
        buildEngine();
        return product;
    }
}
/**
 * 具体建造器类CarBBuilder
 * CarB=JapaneseGlass+AmericanWheel+FranceEngine
 */
class CarBBuilder implements CarBuilder{
    private Car product;
    public CarBBuilder(){
        product=new Car();
    }
    /**
     * 将建造部件的工作封装在getProduct()操作中,主要是为了向客户隐藏实现细节
     * 这样，具体建造类同时又起到了一个director的作用
     */
    @Override
    public void buildEngine() {
        // TODO Auto-generated method stub
        product.engine=new FranceEngine();
    }
    @Override
    public void buildGlass() {
        // TODO Auto-generated method stub
        product.glass=new JapaneseGlass();
    }
    @Override
    public void buildWheel() {
        // TODO Auto-generated method stub
        product.wheel=new AmericanWheel();
    }
    @Override
    public Car getProduct() {
        // TODO Auto-generated method stub
        buildGlass();
        buildWheel();
        buildEngine();
        return product;
    }
}
class Director{
    private CarBuilder builder; 
    public Director(CarBuilder builder) { 
        this.builder = builder; 
    }
    public Car construct() { 
        return builder.getProduct();
    } 
}
/**
 * 客户端代码，使用Director创建两种不同型别的CarA和CarB
 */
public class Test{
    public static void main(String[] args){
        Car carA,carB;
        CarBuilder builderA = new CarABuilder();
        CarBuilder builderB = new CarBBuilder();
        Director director;
        director = new Director(builderA);
        carA=director.construct();
        director = new Director(builderB);
        carB=director.construct();
        System.out.println("Car A is made by:"+carA.glass+carA.wheel+carA.engine);
        System.out.println("Car B is made by:"+carB.glass+carB.wheel+carB.engine);
    }
}

---

效果

1 隐藏产品的内部表示

　　Builder提供创建产品的接口给Director，

　　隐藏了产品的内部结构（仅提供接口BuildPart()创建产品）

　　隐藏该产品是如何装配的(BuildPart()内部装配是隐藏的)。

2 将构造代码和表示代码分开

构造代码是在Builder提供的接口中完成的，每个ConcreateBuilder包含了创建和装配一个特定产品的所有代码。

提供不同的Builder，使用相同的Director导向过程可以得到不同的表示。

将构造代码和表示代码分开，可以使代码得到重用。

3 精确的控制导向产品的创建

　　将代码的构建过程委托为Director去完成，那么Client可以不用关注产品的构建过程

　　何时完成或者完成到什么程度，交给Director去控制产品的创建和装配的过程。并返回所创建的产品，或者通知Client。
　　

---

与Factory的比较

Builder和Factory之间的区别就是组装和生产之间的区别，Builder着重将组装和构件的生产分离，Factory着重于优化生产的过程。本文的代码实际上还可以进行重构，例如，在buildGlass()函数里面，用到了new这个关键字，实际上可以将这个new换成工厂类，让工厂类来生产Glass。换一种说法，就是Factory不进行组装，Builder进行组装，当Factory进行组装的时候，它就变成Builder了。