java设计模式之建造者模式

 建造者模式：
一、定义：将复杂对象的构建过程与其表示分离，使得同样的构建过程可以产生不同的表现形式。
二、优点：解耦，使得复杂对象的创建过程更加清晰，可以根据需求适当调整各部件顺序。扩展具有相同组件，组件顺序不同的产品很方便，只需要在指挥者中修改代码。。
三、缺点：需要有很多相同的组件，范围受限。如果产品组件内部变化很大，则需要实现很多具体建造者，使得系统变得很大。        
四、涉及角色：
         1、建造者builder：提供一个抽象的接口标准，定义了构建复杂对象所需的各部分组件的方法，但不涉及具体的实现逻辑。
         2、具体建造者concrete builder：实现builder接口，实现具体的业务逻辑，定义了各个组件的实现过程，并提供对象实例。
         3、指挥者director：通过调用具体建造者中实现的各个组件的方法，按照一定顺序，构建负责对象，并返回复杂对象。
         4、复杂对象product：要实现的产品。
五、使用场景：多个复杂对象具有相同的基本组件，组件顺序需要变化。
         例如：去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

六、示意图

七：实例代码 

package com.wms.builderPattern;

/**
 * @date:2018/11/13
 * @desc: 岗位 product 要实现的复杂对象。
 */
public class Car {

    private String lunzi;
    private String chexiang;
    private String fangxiangpan;

    public String getLunzi() {
        return lunzi;
    }

    public void setLunzi(String lunzi) {
        this.lunzi = lunzi;
    }

    public String getChexiang() {
        return chexiang;
    }

    public void setChexiang(String chexiang) {
        this.chexiang = chexiang;
    }

    public String getFangxiangpan() {
        return fangxiangpan;
    }

    public void setFangxiangpan(String fangxiangpan) {
        this.fangxiangpan = fangxiangpan;
    }

    @Override
    public String toString() {
        return "Car{" +
                "lunzi='" + lunzi + '\'' +
                ", chexiang='" + chexiang + '\'' +
                ", fangxiangpan='" + fangxiangpan + '\'' +
                '}';
    }
}

package com.wms.builderPattern;

/**
 * @date:2018/11/13
 * @desc: 岗位：建造者 builder
 */
public interface CarBuilder {
    void buildLunzi();
    void buildChexiang();
    void buildFangxiangpan();
    Car buildCar();
}

package com.wms.builderPattern;

/**
 * @date:2018/11/13
 * @desc: 岗位：具体建造者1
 */
public class BaomaCarBuilder implements CarBuilder {

    private Car car = new Car();

    public void buildLunzi() {
        car.setLunzi("宝马车的轮子");

    }

    public void buildChexiang() {
        car.setChexiang("宝马车的车厢");
    }

    public void buildFangxiangpan() {
        car.setFangxiangpan("宝马车的方向盘");
    }

    public Car buildCar() {
        return car;
    }

}

package com.wms.builderPattern;

/**
 * @date:2018/11/13
 * @desc: 岗位：具体建造者2
 */
public class BenchiCarBuilder implements CarBuilder {

    Car car = new Car();

    public void buildLunzi() {
        car.setLunzi("奔驰的轮子");
    }

    public void buildChexiang() {
        car.setChexiang("奔驰的车厢");
    }

    public void buildFangxiangpan() {
        car.setFangxiangpan("奔驰的方向盘");
    }

    public Car buildCar() {
        return car;
    }

}

package com.wms.builderPattern;

/**
 * @date:2018/11/13
 * @desc: 岗位：指挥者director 负责product各部分的构建顺序，并返回复杂对象。
 */
public class Director {

    public Car getCar(CarBuilder carBuilder) {
        carBuilder.buildLunzi();
        carBuilder.buildChexiang();
        carBuilder.buildFangxiangpan();
        return carBuilder.buildCar();
    }

}

package com.wms.builderPattern;

/**
 * @date:2018/11/13
 * @desc:  建造者模式测试      
 */
public class BuilderDemo {

    public static void main(String[] args) {
        //
        Director director = new Director();

        Car baomaCar = director.getCar(new BaomaCarBuilder());
        System.out.println(baomaCar.toString());


        Car BenchiCar = director.getCar(new BenchiCarBuilder());
        System.out.println(BenchiCar.toString());



    }


}

结果： 

Car{lunzi='宝马车的轮子', chexiang='宝马车的车厢', fangxiangpan='宝马车的方向盘'}
Car{lunzi='奔驰的轮子', chexiang='奔驰的车厢', fangxiangpan='奔驰的方向盘'}