建造者模式（Builder）

关注

原创最新推荐文章于 2026-05-12 09:08:00 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

TensorRT工作手册前段时间写了tvm的转换编译部署相关的文章，牛先生：神经网络编译器TVM,autoTVM自动代码优化及c++部署cuda实践20 赞同 · 0 评论文章正在上传…重新上传取消以及tensorrt偏向讲原理的文章：牛先生：tensorRT量化实践手册3 赞同 · 0 评论文章后来发现现在用tensorrt的还更多一些。今天也总结下，tensorrt的对应python接口模型转换，模型推理，模型量化相关的内容。作者做tensorrt在ubuntu桌面和jetson都做了相关的实践。总的.. 阅读详情

    建造模式是一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示，将其复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。
    建造者模式通常包括下面几个角色：	
Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
Product：要创建的复杂对象。
    使用场景： 
需要生成的对象具有复杂的内部结构。 
需要生成的对象内部属性本身相互依赖。
    与工厂模式的区别是：工厂方法模式的对象粒度比较粗，建造者模式的产品对象粒度比较细。建造者模式更加关注与零件装配的顺序。
如下举例说明：汽车厂生产一辆汽车（ConcreteBuilder），内部可分为生产发动机（ProductEngine）、底盘（ProductChassis）和外壳（ProductShell）三个步骤。
汽车生产厂厂长（Diretor）根据市场需要生产不同种类汽车，可供客户选择不同的。
厂长调研后，将生产企业划分为生产发动机（ProductEngine）、底盘（ProductChassis）和外壳（ProductShell）三个步骤。
生产线总管（ConcreteBuilder）去构建；
将组装起来的车进行售卖。
样例如下：

public interface Builder {	
	//生产发动机
	public abstract void buildEngine(String type);
	//生产底盘
	public abstract void buildChassis(String type);
	//生产外壳
	public abstract void buildShell(String type);
	public abstract Car getCar();
}

public class Director {
	//持有当前需要使用的建造器对象
	private Builder builder;	
	//发动机类型
	private String engineType;	
	//底盘类型
	private String chassisType;	
	//外壳类型
	private String shellType;	
	Director(Builder builder) {
		this.builder = builder;
	}	
	public String getEngineType() {
		return engineType;
	}
	public void setEngineType(String engineType) {
		this.engineType = engineType;
	}
	public String getChassisType() {
		return chassisType;
	}
	public void setChassisType(String chassisType) {
		this.chassisType = chassisType;
	}
	public String getShellType() {
		return shellType;
	}
	public void setShellType(String shellType) {
		this.shellType = shellType;
	}
    //产品构造方法，负责调用各个建造方法
    public void construct(){
    	//首先生产发动机
    	//声明为抽象方法，具体由子类实现
        builder.buildEngine(engineType);
    	//其次生产底盘
    	//声明为抽象方法，具体由子类实现 
        builder.buildChassis(chassisType);
    	//最后生产外壳
    	//声明为抽象方法，具体由子类实现 
        builder.buildShell(shellType);
    }
}

//建造者类
public class ConcreteBuilder implements Builder {
	private Car car = new Car();
	@Override
	public void buildEngine(String type) {
		if("engineHigh".equals(type)) {
			Part engine = new EngineHigh();
			car.addPrt(engine);
			System.out.println("生产发动机");
		}
		else if("engineLow".equals(type)) {
			Part engine = new EngineLow();
			car.addPrt(engine);
		}
	}
	@Override
	public void buildChassis(String type) {
		if("chassisHigh".equals(type)) {
			Part chassis = new ChassisHigh();
			car.addPrt(chassis);
		}
		else if("chassisLow".equals(type)) {
			Part chassis = new ChassisLow();
			car.addPrt(chassis);
		}
	}
	@Override
	public void buildShell(String type) {
		if("shellRed".equals(type)) {
			Part shell = new ShellRed();
			car.addPrt(shell);
		}
		else if("shellBlack".equals(type)) {
			Part shell = new ShellBlack();
			car.addPrt(shell);
		}
	}
	@Override
	public Car getCar() {
		return car;
	}
}

public class Car {
	//汽车模块集合
	private List<Part> parts = new ArrayList<Part>();
	//组装零件
	public void addPrt(Part part){
	    parts.add(part);
	}
	//展示生产的零件
	public void showParts() {
		for(Part part: parts)
		{
			System.out.println("已经生产了：" + part.name() + "，价格为： " + part.price());
       }
	}
	//获取当前Car的价格 
	public float getCost() {
		float cost = 0;
		for(Part part: parts)
		{
			cost += part.price();
		}
		return cost;
	}
}

public interface Part {
	//价格
	public float price();
	//名称
	public String name();
}

public abstract class Engine implements Part {
	@Override
	public float price() {
		// TODO Auto-generated method stub
		return 0;
	}
	@Override
	public String name() {
		// TODO Auto-generated method stub
		return null;
	}
}

public class EngineHigh extends Engine {
	public float price() {
		return (float) 10.12;
	}
	public String name() {
		return "高配发动机";
	}
}

public class EngineLow extends Engine {
	public float price() {
		return (float) 10.12;
	}
	public String name() {
		return "高配发动机";
	}
}

public abstract class Chassis implements Part {
	@Override
	public float price() {
		// TODO Auto-generated method stub
		return 0;
	}
	@Override
	public String name() {
		// TODO Auto-generated method stub
		return null;
	}
}

public class ChassisHigh extends Chassis {
	public float price() {
		return (float) 5.3;
	}

	public String name() {
		return "高配底盘";
	}
}

public class ChassisLow extends Chassis {
	public float price() {
		return (float) 3.1;
	}
	public String name() {
		return "低配底盘";
	}
}

public abstract class Shell implements Part {
	@Override
	public float price() {
		// TODO Auto-generated method stub
		return 0;
	}
	@Override
	public String name() {
		// TODO Auto-generated method stub
		return null;
	}
}

public class ShellBlack extends Shell{
	public float price() {
		return (float) 1.9;
	}
	public String name() {
		return "黑色外壳";
	}
}

public class ShellRed extends Shell{
	public float price() {
		return (float) 1.9;
	}
	public String name() {
		return "红色外壳";
	}
}

public class BuilderDemo {	
	public static void main(String[] args) {
	    Builder builder = new ConcreteBuilder();
	    Director director = new Director(builder);
	    director.setEngineType("engineHigh");
	    director.setChassisType("chassisHigh");
	    director.setShellType("shellRed");
	    director.construct();	    
	    Car car = builder.getCar();
	    car.showParts();
	    float price = car.getCost();
	    System.out.println(price);
	}
}

生产发动机
已经生产了：高配发动机，价格为： 10.12
已经生产了：高配底盘，价格为： 5.3
已经生产了：红色外壳，价格为： 1.9
17.32