建造者模式

使用多个简单的对象一步步构建出一个复杂的对象。它属于创建型模式。

适用场景

复杂的对象，但组成该对象部件成分不变，但组合改变的情况

• 例如

  • 计算机由CPU、主板、内存、硬盘、显卡、显示器、键盘和鼠标等等部件组成；
  • 汽车由轮胎、车架、发动机、座椅、空调、方向盘等等部件组成；
  • 一份快餐由两荤两素组成；

四要素

产品 Product

包含多个部件的复杂对象，即最终产品；如电脑、汽车、快餐；

抽象建造者 Builder

创建产品各部件的抽象方法接口，通常还包含返回最终产品的方法；

具体建造者 ConcreteBuilder

实现Build接口，实现具体创建工作；

指挥者 Director

负责调度合适的建造者，按特定顺序构建并组装产品。

实现

public class Car {
    private String engine;
    private String tires;
    private String seats;

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

    public void setTires(String tires) {
        this.tires = tires;
    }

    public void setSeats(String seats) {
        this.seats = seats;
    }
}

public interface CarBuilder {
    void makeEngine();
    void makeTires();
    void makeSeats();
    Car getCar();
}

public class SedanBuilder implements CarBuilder {
    private Car car;
    public SedanBuilder() {
        car = new Car();
    }
    @Override
    public void makeEngine() {
        car.setEngine("轿车发动机");
    }
    @Override
    public void makeTires() {
        car.setTires("轿车轮胎");
    }
    @Override
    public void makeSeats() {
        car.setSeats("轿车座椅");
    }
    @Override
    public Car getCar() {
        return car;
    }
}

public class SUVBuilder implements CarBuilder {
    private Car car;
    public SUVBuilder() {
        car = new Car();
    }
    @Override
    public void makeEngine() {
        car.setEngine("SUV发动机");
    }
    @Override
    public void makeTires() {
        car.setTires("SUV轮胎");
    }
    @Override
    public void makeSeats() {
        car.setSeats("SUV座椅");
    }
    @Override
    public Car getCar() {
        return car;
    }
}

public class CarDirector {
    private CarBuilder carBuilder;
    public CarDirector(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }
    public void constructCar() {
        carBuilder.makeEngine();
        carBuilder.makeTires();
        carBuilder.makeSeats();
    }
    public Car getCar() {
        return carBuilder.getCar();
    }
}

public static void main(String[] args) {
        CarBuilder sedanBuilder = new SedanBuilder();
        CarDirector sedanDirector = new CarDirector(sedanBuilder);
        sedanDirector.constructCar();
        Car sedan = sedanDirector.getCar();
        System.out.println("小轿车：" + sedan);

        CarBuilder suvBuilder = new SUVBuilder();
        CarDirector suvDirector = new CarDirector(suvBuilder);
        suvDirector.constructCar();
        Car suv = suvDirector.getCar();
        System.out.println("SUV：" + suv);
    }

优缺点

优点

扩展性好，建造者相互独立，互不影响，有利于系统解耦；
封装性好，很好的控制构建过程，对客户端隐藏具体构建细节；

缺点

产品组成固定，适合于产品稳定成分不常变更的产品；
系统类和对象数量增加，如产品属性较少，可能会导致代码冗余；