1. 前言
- 在学习建造者模式之前也看过很多文章 都提到了Builder，Director，ConcreteBuilder，Product 这四个角色。这些都是 传统的意义上的设计模式，然而在项目实战中的演变不会存在 Builder，Director 这两个角色。那到底怎么实现的呢，下面是传统的建造者和目前实战中的建造者有啥区别
2.传统建造者是这样的
Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建
/**
* Created by hm on 2019/2/19.
* 抽象建造者
*/
public interface Build
{
public void makeWindow();
public void makeFlow();
public Room build();
}
Director 调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建 （含有建造者的引用）
/**
* Created by hm on 2019/2/19.
* 设计者 知道房屋怎么设计
* 对 工人能力了解
* 持有工人得引用
*/
public class Designer
{
public Room build(Build build){
build.makeFlow();
build.makeWindow();
return build.build();
}
}
Product 要创建的复杂对象
/**
* Created by hm on 2019/2/19.
*/
public class Room
{
private String window;
private String flow;
public String getWindow()
{
return window;
}
public void setWindow(String window)
{
this.window = window;
}
public String getFlow()
{
return flow;
}
public void setFlow(String flow)
{
this.flow = flow;
}
}
ConcreteBuilder 实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。（含有 要创建对象的的引用 ）
/**
* Created by hm on 2019/2/19.
* 建造者持有对房子得引用
*/
public class WorkBuild implements Build
{
Room room=new Room();
@Override
public void makeWindow()
{
room.setWindow("法式窗户");
}
@Override
public void makeFlow()
{
room.setFlow("欧式地板");
}
@Override
public Room build()
{
return room;
}
}
使用
WorkBuild workBuild = new WorkBuild();
Designer designer = new Designer();
Room room = designer.build(workBuild);
Log.i(TAG,room.toString());
3. 项目中的建造者是这样的
- 在room 类中隐藏掉对外提供的set/get方法
public class Room1
{
private String window;
private String flow;
private String cateen;
/**
*
* @param params
* @return
*/
public Room1 apply(WorkBuild1.RoomParams params){
window= params.window;
flow=params.flow;
cateen=params.cateen;
return this;
}
@Override
public String toString()
{
return "Room1{" +
"window=" + window +
"flow=" + flow +
'}';
}
}
- 在 WorkBuild1 类中，同样持有要创建对象（room）的引用，同时还具有和room 一样的参数 ，通过返回WorkBuild1本身达到链式调用的效果，同时也是正真的构建者
public class WorkBuild1
{
Room1 room = new Room1();
private RoomParams params = new RoomParams();
public WorkBuild1 makeWindow(String window)
{
params.window = window;
return this;
}
public WorkBuild1 makeFlow(String flow)
{
params.flow = flow;
return this;
}
/**
* 正真得构建
*
* @return
*/
public Room1 build()
{
room.apply(params);
return room;
}
class RoomParams
{
public String window;
public String flow;
public String cateen;
}
}
使用
Room1 room1 = new WorkBuild1().makeWindow("法式").makeFlow("欧式").build();
简单写法
package com.device_info.hm.testdemo;
/**
* Created by hm on 2019/4/16.
*/
public class Computer
{
private int cpuCounts;
private int mRamSize;
private String Os;
//1.私有构造方法
private Computer(){
}
//2.静态内部类
public static class Builder{
//3.持有外部引用
private Computer computer;
public Builder(){
computer=new Computer();
}
//4.设置配置信息
public Builder setCpuCount(int cpuCounts){
computer.cpuCounts=cpuCounts;
return this;
}
public Builder setRamSize(int mRamSize){
computer.mRamSize=mRamSize;
return this;
}
public Builder setOs(String os){
computer.Os=os;
return this;
}
//将对象返回
public Computer build(){
return computer;
}
}
@Override
public String toString()
{
return "Computer{" +
"cpuCounts=" + cpuCounts +
", mRamSize=" + mRamSize +
", Os='" + Os + '\'' +
'}';
}
}
Computer android = new Computer.Builder().setCpuCount(2).setOs("android").setRamSize(64).build();
总结
构建者模式 屏蔽了对象的构建过程和细节，用户就可以直接创建复杂对象
