生成器设计模式

生成器设计模式：它将复杂对象的构建与其表示相互分离，使得在同样的构建过程中可以创建不同的表示
- 能够从简单的对象一步一步生成复杂的对象。生成器模式是一种用来逐步构建复杂对象并在最后一步返回对象的创造型模式
- 生成器模式隐藏了产品构建过程中的内部细节。各个生成器之间都是相互独立的。这提高了代码的模块化，并使其他的生成器更方便的创建对象。因为每个生成器都能够逐步创建对象，这让我们能够很好的对最终的产品进行掌控
生成器模式UML图
- 生成器类（Builder）：提供一个接口用于创建产品的各个组成部件。具体生成器（ConcreteBuilder）提供此接口的实现
- 具体生成器（ConcreteBuilder）：会跟踪其所创建对象的表现形式，并在创建对象的同时提供一个接口获取产品（Product）
- 导演类（Director）：通过生成器提供的接口构造对象。产品类用于表示被构造的复杂对象。这包括对我们构建的所有类进行定义
  
  [外链图片转存失败(img-yMYwwiuj-1567174768718)(D:\Desktop\设计模式\生成器设计模式.png)]

示例：

/** * @author xiao儿 * @date 2019/8/29 22:33 * @Description CarPlan */
public interface CarPlan {
    public void setBase(String basename);
    public void setWheels(String wheels);
    public void setEngine(String engine);
    public void setRoof(String roof);
    public void setMirrors(String mirrors);
    public void setLights(String lights);
    public void setInterior(String interior);
}

/** * @author xiao儿 * @date 2019/8/29 22:36 * @Description Car * 如果使用了抽象类，那就是对抽象类进行扩展 */
public class Car implements CarPlan {
    private String basename;
    private String wheels;
    private String engine;
    private String roof;
    private String mirrors;
    private String lights;
    private String interior;

    @Override
    public void setBase(String basename) {
        this.basename = basename;
    }

    @Override
    public void setWheels(String wheels) {
        this.wheels = wheels;
    }

    @Override
    public void setEngine(String engine) {
        this.engine = engine;
    }

    @Override
    public void setRoof(String roof) {
        this.roof = roof;
    }

    @Override
    public void setMirrors(String mirrors) {
        this.mirrors = mirrors;
    }

    @Override
    public void setLights(String lights) {
        this.lights = lights;
    }

    @Override
    public void setInterior(String interior) {
        this.interior = interior;
    }
}

/** * @author xiao儿 * @date 2019/8/29 22:40 * @Description CarBuilder * 定义生成器接口 */
public interface CarBuilder {
    public void buildBase();
    public void buildWheels();
    public void buildEngine();
    public void buildRoof();
    public void buildMirrors();
    public void buildLights();
    public void buildInterior();
    public Car getCar();
}

/** * @author xiao儿 * @date 2019/8/29 22:42 * @Description LowPriceCarBuilder * 生成器第一个实现（具体生成器） */
public class LowPriceCarBuilder implements CarBuilder {
    private Car car;

    public LowPriceCarBuilder() {
        car = new Car();
    }

    @Override
    public void buildBase() {
        car.setBase("Low priced base");
    }

    @Override
    public void buildWheels() {
        car.setWheels("Cheap Tyres");
    }

    @Override
    public void buildEngine() {
        car.setEngine("Low Quality Engine");
    }

    @Override
    public void buildRoof() {
        car.setRoof("No flexible roof");
    }

    @Override
    public void buildMirrors() {
        car.setMirrors("Cheap Mirrors");
    }

    @Override
    public void buildLights() {
        car.setLights("Cheap Lights");
    }

    @Override
    public void buildInterior() {
        car.setInterior("Cheap Interior");
    }

    @Override
    public Car getCar() {
        return this.car;
    }
}

/** * @author xiao儿 * @date 2019/8/29 22:49 * @Description HighEndCarBuilder * 生成器的第二个实现（具体生成器） */
public class HighEndCarBuilder implements CarBuilder {
    private Car car;

    public HighEndCarBuilder() {
        car = new Car();
    }

    @Override
    public void buildBase() {
        car.setBase("Quality base");
    }

    @Override
    public void buildWheels() {
        car.setWheels("Quality Tyres");
    }

    @Override
    public void buildEngine() {
        car.setEngine("High-end Engine");
    }

    @Override
    public void buildRoof() {
        car.setRoof("Flexible roof");
    }

    @Override
    public void buildMirrors() {
        car.setMirrors("Quality Mirrors");
    }

    @Override
    public void buildLights() {
        car.setLights("Quality Lights");
    }

    @Override
    public void buildInterior() {
        car.setInterior("High-end Interior");
    }

    @Override
    public Car getCar() {
        return this.car;
    }
}

/** * @author xiao儿 * @date 2019/8/29 22:54 * @Description MechanicalEngineer * 导演类 */
public class MechanicalEngineer {
    private CarBuilder carBuilder;

    public MechanicalEngineer(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public Car getCar() {
        return carBuilder.getCar();
    }

    public void buildCar() {
        carBuilder.buildBase();
        carBuilder.buildWheels();
        carBuilder.buildEngine();
        carBuilder.buildRoof();
        carBuilder.buildMirrors();
        carBuilder.buildLights();
        carBuilder.buildInterior();
    }
}

/** * @author xiao儿 * @date 2019/8/29 22:57 * @Description Main */
public class Main {
    public static void main(String[] args) {
        CarBuilder lowPriceCarBuilder = new LowPriceCarBuilder();
        MechanicalEngineer engineer = new MechanicalEngineer(lowPriceCarBuilder);
        engineer.buildCar();
        Car car = engineer.getCar();
        System.out.println("Builder Constructed Car：" + car);
    }
}

生成器模式举例
- 在Java API中，StringBuffer和StringBuilder及时生成器模式的适用示例
抽象工厂模式和生成器模式之间的区别

抽象工厂也可以用于构建一个复杂的对象。在生成器模式中，核心hi逐步完成对象构建。生成器模式将对象构建的过程分解为很多个小步骤。在每一步中又能够包含不同的构建逻辑。

同时，生成器模式还包含了一个对象构建序列。它会从步骤1开始运行一直到步骤n，并在最后一步完成后返回构建完成的对象。在这些步骤中，每一步都将向对象中添加一些逻辑或参数值。在抽象模式中尽管也可以构建相当复杂的对象，但它不会使用步骤来完成对象构造。

在抽象工厂模式中，主要是由工厂根据需要主动创建各种子类型的对象。

抽象工厂方法模式的用户不需要知道该对象确切的子类型。

生成器模式描述对象时已经明确了对象的类型，只不过还需要通过若干不同的步骤来实现对象不同的表示方法

生成器设计模式

生成器设计模式

生成器设计模式：它将复杂对象的构建与其表示相互分离，使得在同样的构建过程中可以创建不同的表示

生成器模式UML图

示例：

生成器模式举例

抽象工厂模式和生成器模式之间的区别