创建型模式:(省去new对象,帮助我们更好的创建对象)
单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
结构型模式:
设配器模式、桥接模式、装饰模式、组合模式、、外观模式、亨元模式、代理模式
行为型模式:
模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式
建造者模式
建造者模式也属于创建型模式,他提供了一种创建对象的最佳方式。
定义:将一个复杂对象的构建与他的表示分离,使同样的构建过程可以创建不同的表示
主要作用:在用户不知道 对象的建造和细节 的情况下就可以直接创建复杂的对象
用户只需要给出指定复杂对象的类型和内容,建造者模式负责按顺序创建复杂对象(把内部的建造过程和细节隐藏起来)
例子:
工厂(建造者模式):负责制造汽车(组装过程和细节在工厂内)
汽车购买者(用户):你只需要说出你需要的型号(对象的类型和内容),然后直接购买就可以使用了(不要知道汽车是怎么组装的(车轮、车门、发动机、方向盘等等))
代码
抽象构建者 Builder
//抽象的建造者 : 不负责建造 只是负责定义一些方法与接口
public abstract class Builder {
abstract void bulidA(); //地基
abstract void bulidB(); //钢筋工程
abstract void bulidC(); //铺电线
abstract void bulidD(); //粉刷
//做完上面的步骤之后会生成一个产品
abstract Product getproduct();
}
产品Produce
// 产品 做完地基 钢筋水泥 电线 粉刷后生成的产品
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 + '\'' +
'}';
}
}
具体的建造者:工人 Worker
//具体的建造者:工人
public class Worker extends Builder{
//工人需要完成一个产品
private Product product;
//产品是由工人创建的(而不是通过构造器传入)
public Worker() {
product = new Product();
}
@Override
void bulidA() {
// 创建产品 Product实现了Builder(抽象创建者)的抽象方法
product.setBuildA("地基");
System.out.println("地基");
}
@Override
void bulidB() {
product.setBuildB("钢筋工程");
System.out.println("钢筋工程");
}
@Override
void bulidC() {
product.setBuildC("铺电线");
System.out.println("铺电线");
}
@Override
void bulidD() {
product.setBuildD("粉刷");
System.out.println("粉刷");
}
@Override
Product getproduct() {
return product;
}
}
指挥 :核心 Director
//指挥: 核心 负责指挥构建一个工程 工程如何构建由他决定
public class Director {
//指挥者负责指挥他安装顺序生成一个产品(核心构建顺序)
//指挥一个抽象建造者(builder可能传入不同的工人)
public Product build(Builder builder){
builder.bulidA();
builder.bulidB();
builder.bulidC();
builder.bulidD();
return builder.getproduct();
}
}
测试类 TestBuilder
public class TestBuilder {
public static void main(String[] args) {
//指挥
Director director = new Director();
//指挥具体的工人完成产品
Product build = director.build(new Worker());
System.out.println(build.toString());
}
}
结果
指挥者可以控制调用,具体的工人不需要改变
第一种核心是指挥者,指挥者最终交给客户。第二种方式不需要指挥者
建造者:Builder
//建造者
public abstract class Builder {
//为了方便用户传入需求 定义一些参数。若不赋值参数 就是默认Produce的套餐
abstract Builder bulidA(String msg); //汉堡
abstract Builder bulidB(String msg); //可乐
abstract Builder bulidC(String msg); //薯条
abstract Builder bulidD(String msg); //甜点
//固定 建造者模式就是为了建造产品 只是建造这些产品的时候可能出现一些默认值
abstract Product getProduct();
}
产品 : Produce
//产品: 具体的套餐
public class Product {
//固定套餐
private String buildA="汉堡";
private String buildB="可乐";
private String buildC="薯条";
private String buildD="甜点";
//自己选择套餐
public void setBuildA(String buildA) {
this.buildA = buildA;
}
public void setBuildB(String buildB) {
this.buildB = buildB;
}
public void setBuildC(String buildC) {
this.buildC = buildC;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return "Product{" +
"buildA='" + buildA + '\'' +
", buildB='" + buildB + '\'' +
", buildC='" + buildC + '\'' +
", buildD='" + buildD + '\'' +
'}';
}
}
具体建造者: Worker
//具体建造者
public class Worker extends Builder{
Product product;
public Worker() {
product = new Product();
}
//work.buildA 返回的是Builder 可以继续调用build* .getproduct
@Override
Builder bulidA(String msg) {
product.setBuildA(msg);
return this;
}
@Override
Builder bulidB(String msg) {
product.setBuildB(msg);
return this;
}
@Override
Builder bulidC(String msg) {
product.setBuildC(msg);
return this;
}
@Override
Builder bulidD(String msg) {
product.setBuildD(msg);
return this;
}
@Override
Product getProduct() {
return product;
}
}
测试一:默认情况
public class BuilderChainTest {
public static void main(String[] args) {
//服务员
Worker worker = new Worker();
Product product = worker.getProduct();
System.out.println(product.toString());
}
}
测试二:链式编程 自定义内容
public class BuilderChainTest {
public static void main(String[] args) {
//服务员
Worker worker = new Worker();
//链式编程:在原来的基础上可以自由组合了,如果不组合也有默认的套餐
//work.buildA 返回的是Builder 可以继续调用build* 然后 .getproduct
Product product = worker.bulidA("三明治").bulidB("雪碧")
.getProduct();
System.out.println(product.toString());
}
}