一.例子
案例说明
设计图
代码
1.抽象汽车类
/**
* @ClassName CarModel
* @Description TODO 抽象汽车模型，细节基本在子类中都有实现,细节封装，建造者负责控制控制数量和顺序.
* @Author Administrator
* Date 2019/4/3 21:58
* Version 1.0
*/
public abstract class CarModel {
private List<String> sequeence;
public abstract void stop();
public abstract void start();
public abstract void alarm();
public abstract void egninner();
//运行流程
public void run(){
for(String sequeence:sequeence){
if(sequeence.equals("start")){
start();
}
if(sequeence.equals("stop")){
stop();
}
if(sequeence.equals("alarm")){
alarm();
}
if(sequeence.equals("enginee")){
egninner();
}
}
}
public void setSequeence(List<String> sequeence) {
this.sequeence = sequeence;
}
}
2.宝马车类
/**
* @ClassName BwmCar
* @Description TODO 宝马车，对宝马车的实现细节进行封装
* @Author Administrator
* Date 2019/4/3 23:02
* Version 1.0
*/
public class BwmCar extends CarModel{
@Override
public void stop() {
System.out.println("宝马车停下了");
}
@Override
public void start() {
System.out.println("宝马车启动了");
}
@Override
public void alarm() {
System.out.println("宝马车在鸣笛");
}
@Override
public void egninner() {
System.out.println("宝马车引擎启动");
}
}
3.奔驰车类
/**
* @ClassName BenziCar
* @Description TODO 奔驰车实现类，对奔驰车的实现细节进行封装
* @Author Administrator
* Date 2019/4/3 23:01
* Version 1.0
*/
public class BenziCar extends CarModel {
@Override
public void stop() {
System.out.println("奔驰车停下了");
}
@Override
public void start() {
System.out.println("奔驰车启动了");
}
@Override
public void alarm() {
System.out.println("奔驰车在鸣笛");
}
@Override
public void egninner() {
System.out.println("奔驰车引擎启动");
}
}
4.抽象汽车建造者类
/**
* @ClassName CarModelBuilder
* @Description TODO 抽象建造者
* @Author Administrator
* Date 2019/4/3 22:03
* Version 1.0
*/
public abstract class CarModelBuilder {
/**建造者返回对象
* */
public abstract CarModel getCarModel();
/**setPart,细节组装
* */
public abstract void setSequeen(List<String> sequeen);
}
5、奔驰车建造者类
/**
* @ClassName BneciCarBuilder
* @Description TODO 奔驰车建造者,建造者容易扩展，种类可能比较多
* @Author Administrator
* Date 2019/4/3 23:03
* Version 1.0
*/
public class BenciCarBuilder extends CarModelBuilder {
private CarModel carModel=new BenziCar();
@Override
public CarModel getCarModel() {
return this.carModel;
}
@Override
public void setSequeen(List<String> sequeen) {
carModel.setSequeence(sequeen);
}
}
6、宝马车建造者类
/**
* @ClassName BwmCarBuilder
* @Description TODO 宝马车的建造者
* @Author Administrator
* Date 2019/4/4 10:51
* Version 1.0
*/
public class BwmCarBuilder extends CarModelBuilder{
private CarModel carModel=new BwmCar();
@Override
public CarModel getCarModel() {
return carModel;
}
@Override
public void setSequeen(List<String> sequeen) {
carModel.setSequeence(sequeen);
}
}
7、导演类
/**
* @ClassName Director
* @Description TODO 建造者的导演类,负责对建造者封装，防止上层类深入到建造者类中。
* @Author Administrator
* Date 2019/4/4 10:49
* Version 1.0
*/
public class Director {
private BenciCarBuilder benciCarBuilder=new BenciCarBuilder();
private BwmCarBuilder bwmCarBuilder=new BwmCarBuilder();
/**生产A类奔驰车
* */
public CarModel createABenChiCar(){
List<String> sequeence=new ArrayList<>();
sequeence.add("start");
sequeence.add("stop");
sequeence.add("alarm");
sequeence.add("enginee");
benciCarBuilder.setSequeen(sequeence);
return benciCarBuilder.getCarModel();
}
/**生产B类奔驰车
* */
public CarModel createBBenChiCar(){
List<String> sequeence=new ArrayList<>();
sequeence.add("start");
sequeence.add("stop");
sequeence.add("alarm");
// sequeence.add("enginee");
benciCarBuilder.setSequeen(sequeence);
return benciCarBuilder.getCarModel();
}
/**生产A类宝马车
* */
public CarModel createABwmCar(){
List<String> sequeence=new ArrayList<>();
sequeence.add("start");
sequeence.add("stop");
sequeence.add("alarm");
sequeence.add("enginee");
bwmCarBuilder.setSequeen(sequeence);
return bwmCarBuilder.getCarModel();
}
/**生产B类宝马车
* */
public CarModel createBBwmCar(){
List<String> sequeence=new ArrayList<>();
sequeence.add("start");
sequeence.add("stop");
sequeence.add("alarm");
//sequeence.add("enginee");
bwmCarBuilder.setSequeen(sequeence);
return bwmCarBuilder.getCarModel();
}
}
8.场景类
/**
* @ClassName Client
* @Description TODO 建造者模式场景类
* @Author Administrator
* Date 2019/4/3 23:05
* Version 1.0
*/
public class Client {
public static void main(String[]args){
//
for(int i=0;i<10;i++){
Director director=new Director();
CarModel carModel=director.createABenChiCar();
carModel.run();
}
for(int i=0;i<10;i++){
Director director=new Director();
CarModel carModel=director.createBBenChiCar();
carModel.run();
}
}
}
9.运行结果
奔驰车启动了
奔驰车停下了
奔驰车在鸣笛
奔驰车引擎启动
奔驰车启动了
奔驰车停下了
奔驰车在鸣笛
奔驰车引擎启动
奔驰车启动了
奔驰车停下了
奔驰车在鸣笛
奔驰车引擎启动
奔驰车启动了
奔驰车停下了
奔驰车在鸣笛
奔驰车引擎启动
奔驰车启动了
奔驰车停下了
二.结构
结构图
角色
1.产品类，通常是一系列或者组合产品，采用模板模式构建，上例中的CarModel和BenciCar还有BwmCar为一系列产品，公开自己的逻辑逻辑处理方法让建造者去封装。
2.抽象建造者类，规范产品的建造。
3.具体建造者类，实现抽象建造者的所有方法，构建产品细节。
4.导演类，对建造者进行封装，防止高层类深入到建造者类中造成影响，如果建造者模式比较庞大的时候，可以有多个导演类
通用类代码：
1.抽象建造者类
public abstract class AbstractBuilder {
public abstract void setPart();
public abstract Product getProduct();
}
2.具体建造者
/**
* @ClassName Concrete
* @Description TODO 具体建造者
* @Author Administrator
* Date 2019/4/4 14:05
* Version 1.0
*/
public class ConcreteBuilder extends AbstractBuilder {
private Product product=new Product();
@Override
public void setPart() {
//组装细节，设置产品零件
}
@Override
public Product getProduct() {
return product;
}
}
3.产品类
/**
* @ClassName Product
* @Description TODO 产品
* @Author Administrator
* Date 2019/4/4 13:55
* Version 1.0
*/
public class Product {
public void doSomething(){
//独立产品内部处理业务
}
}
4.导演类
/**
* @ClassName Director
* @Description TODO 导演类，对建造者进行封装.
* @Author Administrator
* Date 2019/4/4 14:00
* Version 1.0
*/
public class Director {
private ConcreteBuilder concreteBuilder=new ConcreteBuilder();
public Product getProduct(){
concreteBuilder.setPart();
Product product=concreteBuilder.getProduct();
return product;
}
}
三.优势
1.将对象的组成细节封装，客户端不需要知道对象的组成细节
2.建造者容易扩展，又相互对立，互不影响。
3.建造者之间相互独立，故而可以对建造过程逐步细化，而不对其它模块产生影响。
网友评论