建筑大师-建造者模式

概述

建造者模式（Builder Pattern）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定

类图

建造者模式中有4种角色：

• 产品类Car。负责定义具体的产品
• 抽象建造者AbstractCarBuilder。规范产品的组建方式，一般具体的实现由子类完成
• 具体建造者BenzCarBuilder、BWMCarBuilder。实现抽象建造者，并组装好返回产品
• 导演类CarDirector。负责安排好已有模块的顺序，然后协调具体的建造者进行组装产品。

代码实现

//产品类
public class Car {

    //车架
    private String frame;
    //发动机
    private String engine;
    //轮胎
    private String tyre;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getEngine() {
        return engine;
    }

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

    public String getTyre() {
        return tyre;
    }

    public void setTyre(String tyre) {
        this.tyre = tyre;
    }

    public String toString(){
        return "Car Information:" + frame + "," + engine + "," + tyre;
    }
}

//抽象建造者
public abstract class AbstractCarBuilder {
    public abstract void setFrame();
    public abstract void setEngine();
    public abstract void setTyre();
    public abstract Car getCart();
}

//具体建造者
public class BenzCarBuilder extends AbstractCarBuilder {

    private Car car;

    public BenzCarBuilder(){
        this.car = new Car();
    }

    @Override
    public void setFrame() {
        this.car.setFrame("Benz Frame");
    }

    @Override
    public void setEngine() {
        this.car.setEngine("Benz Engine");
    }

    @Override
    public void setTyre() {
        this.car.setTyre("Benz tyre");
    }

    @Override
    public Car getCart() {
        return car;
    }
}


//具体建造者
public class BWMCarBuilder extends AbstractCarBuilder {

    private Car car;

    public BWMCarBuilder(){
        this.car = new Car();
    }

    @Override
    public void setFrame() {
        this.car.setFrame("BWM Frame");
    }

    @Override
    public void setEngine() {
        this.car.setEngine(" BWM Engine");
    }

    @Override
    public void setTyre() {
        this.car.setTyre("BWM Tyre");
    }

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

//导演类
public class CarDirector {
    private AbstractCarBuilder carBuilder;

    public CarDirector(AbstractCarBuilder carBuilder){
        this.carBuilder = carBuilder;
    }

    public void creatCar(){
        carBuilder.setFrame();
        carBuilder.setEngine();
        carBuilder.setTyre();
    }
    public Car getCar(){
        return carBuilder.getCart();
    }
}

public class Client {
    public static void main(String[] args){
        BenzCarBuilder benzCarBuilder = new BenzCarBuilder();
        CarDirector carDirector = new CarDirector(benzCarBuilder);
        carDirector.creatCar();
        Car car = carDirector.getCar();
        System.out.println(car.toString());
}

输出结果：
Car Information:Benz Frame,Benz Engine,Benz tyre

优缺点

优点

• 使用建造者模式可以使客户端不必知道产品内部组成的细节
• 具体的建造者类之间是相互独立的，这有利于系统的扩展
• 具体的建造者相互独立，因此可以对建造的过程逐步细化，而不会对其他模块产生任何影响

缺点

• 产品必须有共同点，范围有限制
• 内部变化大会导致有很多建造类，增加了系统的复杂度

使用场景

相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式

• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适

注意事项

建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同

总结一下

• 建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
• 主要解决的问题：在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定
• 四种角色：
  • 产品类
  • 抽象建造者
  • 具体建造者
  • 导演类
• 优点
  • 使用建造者模式可以使客户端不必知道产品内部组成的细节
  • 具体的建造者类之间是相互独立的，这有利于系统的扩展
  • 具体的建造者相互独立，因此可以对建造的过程逐步细化，而不会对其他模块产生任何影响
• 缺点
  • 产品必须有共同点，范围有限制
  • 内部变化大会导致有很多建造类，增加了系统的复杂度
• 注意事项：建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同

欢迎您关注Java天堂公众号，专注于分享Java相关技术