设计模式之建造者模式
建造者模式 属于 创建型模式，提供一种创建对象的最佳方式。
创建型模式 指不是直接使用new的方法，提供另外一种创建对象的方式，并向调用者隐藏 创建对象的细节，该模式使创建对象更加的灵活。
建造者模式
简介
将简单对象一步步的构建为复杂的对象。换句话说，就是将复杂的对象的构建与表示进行分离。
有顺序的创建复杂对象。
模式原理
该模式有四个角色。
- Product：最终生成的对象 产品者
- Builder：构建者的抽象基类，定义创建产品的抽象步骤。一般为抽象类(有时会用接口代替)。在其中会有一个返回产品的方法。抽象建造者
- ConcreteBuilder：继承Builder类，实现抽象方法，该类实现产品的生成。 实际建造者
- Director:该类 指导实际建造者 如何生成产品。 指挥者
UML类图
该图片引用于菜鸟教程。
生活实例
可能看这些术语懵懵的，我们来点与生活相关的实例。
既然 创建型模式 是创建对象，那我们也来创建一个对象。
比如说，我们现在要创建一个 自行车。
一个自行车 由很多部件组成
假设 是一个框架，一个座位，还有轮胎组成。
自行车 可能会有不同的厂家生产，需要定一个标准，让各大厂家遵守这个规则生产。
不同厂家，生产这些部件的方式 可能不同,但都需要实现上面的标准。
光生产这些部件不行，还要把他们组装起来才能够用，并且还需要按照一定的顺序才行。
这个例子 我们来一一对应四个角色。
自行车-->产品者
标准-->抽象建造者
不同的厂家--> 实际建造者。
部件组装-->指挥者。
代码实现
下面我们用代码来实现上面的思路。
自行车类 产品者
package create.builder.bike;
public class Bike {
private String frame;
private String seat;
private String tire;
public String getFrame() {
return frame;
}
public void setFrame(String frame) {
this.frame = frame;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
public String getTire() {
return tire;
}
public void setTire(String tire) {
this.tire = tire;
}
@Override
public String toString() {
return "Bike{" +
"frame='" + frame + '\'' +
", seat='" + seat + '\'' +
", tire='" + tire + '\'' +
'}';
}
}
行业标准 抽象建造者
//抽象建造者 定义了构建产品的步骤
public abstract class Builder {
abstract void buildFrame();
abstract void buildSeat();
abstract void buildTire();
abstract Bike createBike();//返回一个对象的方法
}
不同厂家 实际建造者
摩拜单车(摩拜打钱)
package create.builder.bike;
//摩拜单车
//实际真正的建造者
public class MobikeBuilder extends Builder {
private Bike mBike = new Bike();
@Override
void buildFrame() {
mBike.setFrame("mobike");
}
@Override
void buildSeat() {
mBike.setSeat("mobikeSeat");
}
@Override
void buildTire() {
mBike.setTire("mobikeTire");
}
@Override
Bike createBike() {
return mBike;
}
@Override
public String toString() {
return "MobikeBuilder{" +
"mBike=" + mBike +
'}';
}
}
ofo单车(ofo打钱)
package create.builder.bike;
public class OfoBuilder extends Builder {
private Bike oBike = new Bike();
@Override
void buildFrame() {
oBike.setFrame("OfoBike");
}
@Override
void buildSeat() {
oBike.setSeat("OfoBikeSeat");
}
@Override
void buildTire() {
oBike.setTire("OfoBike");
}
@Override
Bike createBike() {
return oBike;
}
@Override
public String toString() {
return "OfoBuilder{" +
"oBike=" + oBike +
'}';
}
}
部件组装 指挥者
public class Director {
//传递过来真正的建造者。
private Builder mBuilder ;
public Director(Builder builder) {//注入真正的建造者
mBuilder = builder;
}
public Bike construct() {
//告诉具体建造者如何建造产品 最终决定 构建的顺序。
//控制建造的先后顺序 以及返回产品。
mBuilder.buildFrame();
mBuilder.buildSeat();
mBuilder.buildTire();
return mBuilder.createBike();
}
}
模拟客户 来要车
public class Client {
public static void main(String[] args) {
//客户 找 指挥者 要车，要什么车 就new 哪个工厂的车。
//然后 生产一个车给客户。
//客户完全不要关心 自行车是怎么创建出来的，只管找指挥者要就行了。
//再次实现了 创建型模式 向调用者隐藏创建细节的要求。
Director director = new Director(new MobikeBuilder());
Bike bike = director.construct();
System.out.println(bike.toString());
Director director2 = new Director(new OfoBuilder());
Bike bike2 = director2.construct();
System.out.println(bike2.toString());
}
}
实验结果
整理思路
我们再来理一遍思路。
- 客户 找 指挥者要车
- 指挥者 找 真正的建造者要车部件
- 真正的建造车 生产出车部件给指挥者
- 指挥者 将车部件 按照顺序组装，然后给客户。
重新思考
我们再来思考之前的那个简介
建造者模式 是将简单对象构建为复杂对象。
自行车的各个部件是一个简单对象。
自行车 是一个复杂对象。
在 这个实例中 我为了简化代码 是将Frame Seat Tire简化为String 类型。
实际上 他们也是一个类型。按照实际的话应该这样写
privat Frame frame;
privat Seat seat;
privat Tire tire;
我们组装自行车(复杂对象)，就像是搭积木一样，一个一个部件(简单对象)的往上面加，之后再构成我们想要的自行车（复杂对象）。
建议看完后 自己上手 实际敲一遍，这样印象更加深刻。
与抽象工厂模式的联系
抽象工厂也是生产产品的。它是工厂的工厂，生产的是一系列的独立的产品。而建造者模式 生产的是不同产品的组装，是一个组装好的完整产品。
我们可以将 不同厂家生产 自行车的部件(
MobikeBuilder)，使用抽象工厂模式。配件生产工厂
而将自行车的组装 使用建造者模式。配件组装工厂
如果不懂抽象工厂，可以去看看我的这篇文章。
作业实践
使用建造者模式 生产一台笔记本电脑。
声明
本篇文章借鉴于 一篇文章就彻底弄懂建造者模式
特向原作者表示感谢！
如果有任何疑问，请在评论区留言，我将知无不言言无不尽。
最后，码字不易。如果本篇文章对你有些许的帮助，还请帮我点个赞，评论一下。
你的赞同是我创作的最大动力。
