需求:创建复杂的对象---通过简单的对象的自由组合,返回一个完整的产品。
意图:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。
主要解决:主要解决在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。
何时使用:一些基本部件不会变,而其组合经常变化的时候。
如何解决:将变与不变分离开。
关键代码:建造者:创建和提供实例,导演:管理建造出来的实例的依赖关系。
最基础代码思路:
创建一个抽象类的建造者 用来定义生产 哪些模块
package cn.xzc.test.builderMode;
/*
* 建造者模式 创建者模式的一种
* 复杂的类通过 简单的类 组合而来
*
*
* */
public abstract class Builder {
abstract void BuildeA();
abstract void BuildeB();
abstract void BuildeC();
abstract void BuildeD();
abstract Product getProduct();
}
创建产品
public class Product {
private String buildA;
private String buildB;
private String buildC;
private String buildD;
public String getBuildA() {
return buildA;
}
public void setBuildA(String buildA) {
this.buildA = buildA;
}
public String getBuildB() {
return buildB;
}
public void setBuildB(String buildB) {
this.buildB = buildB;
}
public String getBuildC() {
return buildC;
}
public void setBuildC(String buildC) {
this.buildC = buildC;
}
public String getBuildD() {
return buildD;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return "product{" +
"buildA='" + buildA + '\'' +
", buildB='" + buildB + '\'' +
", buildC='" + buildC + '\'' +
", buildD='" + buildD + '\'' +
'}';
}
}
建造一个工作者集成抽象类建造者用来实际生产产品
package cn.xzc.test.builderMode02.demo01;
public class Worker extends Builder{
private Product product;
public Worker() {
product = new Product();
}
@Override
void BuildeA() {
product.setBuildA("A");
System.out.println(product.getBuildA());
}
@Override
void BuildeB() {
product.setBuildB("B");
System.out.println(product.getBuildB());
}
@Override
void BuildeC() {
product.setBuildC("C");
System.out.println(product.getBuildC());
}
@Override
void BuildeD() {
product.setBuildD("D");
System.out.println(product.getBuildD());
}
@Override
Product getProduct(){
return product;
}
}
建造一个指挥者来控制生产者去生产产品
package cn.xzc.test.builderMode02.demo01;
/*
* 指挥 核心 指定生产者按一定顺序去建造出产品
* */
public class Director {
public Product build(Builder builder){
builder.BuildeA();
builder.BuildeB();
builder.BuildeC();
builder.BuildeD();
return builder.getProduct();
}
}
最后测试‘
public class TestForBuildMode {
public static void main(String[] args) {
Director director= new Director();
Product build= director.build(new Worker());
System.out.println(build);
}
}
进阶思考
通常我们的建造顺序不需要写死,建造的内容也需要传参来决定,用户作为调用者自己决定顺序和具体传入参数。
改造建造者可以传入参数 和返回参数
/*
* 建造者模式 创建者模式的一种
* 复杂的类通过 简单的类 组合而来
*
* 添加传入参数和返回值
*
* */
public abstract class Builder {
abstract Builder BuildeA(String msg);
abstract Builder BuildeB(String msg);
abstract Builder BuildeC(String msg);
abstract Builder BuildeD(String msg);
abstract Product getProduct();
}
改造工作者 继承的建造者建造产品的方法返回this 实现链式编程
/*
* 实现工人类来执行产品生产 返回值为this 实现链式编程
* */
public class Worker extends Builder {
private Product product;
public Worker() {
product = new Product();
}
@Override
Builder BuildeA(String msg) {
product.setBuildA(msg);
return this;
}
@Override
Builder BuildeB(String msg) {
product.setBuildB(msg);
return this;
}
@Override
Builder BuildeC(String msg) {
product.setBuildC(msg);
return this;
}
@Override
Builder BuildeD(String msg) {
product.setBuildD(msg);
return this;
}
@Override
Product getProduct(){
return product;
}
}
产品给默认参数 同时可接受工作者传参
package cn.xzc.test.builderMode02.demo02;
public class Product {
private String buildA = "A1";
private String buildB = "B1";
private String buildC = "C1";
private String buildD = "D1";
public String getBuildA() {
return buildA;
}
public void setBuildA(String buildA) {
this.buildA = buildA;
}
public String getBuildB() {
return buildB;
}
public void setBuildB(String buildB) {
this.buildB = buildB;
}
public String getBuildC() {
return buildC;
}
public void setBuildC(String buildC) {
this.buildC = buildC;
}
public String getBuildD() {
return buildD;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return "product{" +
"buildA='" + buildA + '\'' +
", buildB='" + buildB + '\'' +
", buildC='" + buildC + '\'' +
", buildD='" + buildD + '\'' +
'}';
}
}
最后测试
public class TestForBuildMode {
public static void main(String[] args) {
Worker worker= new Worker();
Product product = worker.BuildeA("f").BuildeD("g").BuildeC("c").getProduct();
System.out.println(product.toString());
}
}