《设计模式》设计模式的基本原则
《设计模式》单例模式
《设计模式》工厂模式
《设计模式》原型模式
《设计模式》建造者模式
《设计模式》适配器模式
《设计模式》桥接模式
《设计模式》装饰者模式
《设计模式》组合模式
《设计模式》外观模式
《设计模式》享元模式
《设计模式》代理模式
《设计模式》模板方法模式
《设计模式》命令模式
《设计模式》建造者模式
定义：
- 建造者模式又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
- 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
建造者模式的四个角色：
- Product(产品角色)：一个具体的产品对象
- Builder(抽象建造者)：创建一个 Product 对象的各个部件指定的接口/抽象类
- ConcreteBuilder(具体建造者)：实现接口，构建和装配各个部件
- Director(指挥者)：构建一个使用 Builder 接口的对象，它主要用于创建一个复杂的对象，有两个作用：1. 隔离了客户与对象的生产过程 2. 负责控制产品对象的生产过程。
建造者模式的注意事项：
- 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
- 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更为清晰，可以更精细地控制创建产品的过程
- 增加新的具体建造者无需修改原有类库代码，指挥者针对抽象建造者类编程，系统扩展方便符合开闭原则
- 建造者模式所创建的产品一般都具有较多的共同点，如果产品之间的差异性很大则不适合使用建造者模式，因此其使用范围受到限制
- 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者来实现这种变化，导致系统变得很庞大，因此这种情况下考虑是否还要选择建造者模式
建造者模式原理 UML 类图如下所示：
现在有一个盖房子的项目，需求如下：
- 盖房过程为打桩、砌墙、封顶
- 房子的类型很多，如普通房、高楼、别墅
- 各种类型的房子建造过程虽然相同，但是具体的要求不一样
传统的思维方式分析该项目，其 UML 图如下所示：
AbstractHouse 类
public abstract class AbstractHouse {
public abstract void buildBasic();
public abstract void buildWalls();
public abstract void roofed();
public void build() {
buildBasic();
buildWalls();
roofed();
}
}
CommonHouse 类
public class CommonHouse extends AbstractHouse{
@Override
public void buildBasic() {
System.out.println("普通房子打地基");
}
@Override
public void buildWalls() {
System.out.println("普通房子砌墙");
}
@Override
public void roofed() {
System.out.println("普通房子封顶");
}
}
Client 类
public class Client {
public static void main(String[] args) {
CommonHouse commonHouse = new CommonHouse();
commonHouse.build();
}
}
传统方式实现简单易于操作，但是由于过于简单没有设计缓存层对象，也就是说将房子和建房子的过程封装在了一起，增加了耦合性，导致程序的扩展性和维护性不是很好。
因此，使用建造者模式的设计思想，将房子和建房子的过程解耦，其 UML 类图如下所示：
House 类
public class House {
private String basic;
private String wall;
private String roofed;
public String getBasic() {
return basic;
}
public void setBasic(String basic) {
this.basic = basic;
}
public String getWall() {
return wall;
}
public void setWall(String wall) {
this.wall = wall;
}
public String getRoofed() {
return roofed;
}
public void setRoofed(String roofed) {
this.roofed = roofed;
}
}
HouseBuilder 类
public abstract class HouseBuilder {
protected House house = new House();
public abstract void buildBasic();
public abstract void buildWalls();
public abstract void roofed();
public House buildHouse() {
return house;
}
}
CommonHouse 类
public class CommonHouse extends HouseBuilder{
@Override
public void buildBasic() {
System.out.println("普通房子打地基5米");
}
@Override
public void buildWalls() {
System.out.println("普通房子砌墙10公分");
}
@Override
public void roofed() {
System.out.println("普通房子封顶");
}
}
HighBuilding 类
public class HighBuilding extends HouseBuilder{
@Override
public void buildBasic() {
System.out.println("高楼打地基100米");
}
@Override
public void buildWalls() {
System.out.println("高楼砌墙20公分");
}
@Override
public void roofed() {
System.out.println("高楼封顶");
}
}
HouseDirector 类
public class HouseDirector {
HouseBuilder houseBuilder = null;
public HouseDirector(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
public void setHouseBuilder(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
//房子的建造流程交给指挥者
public House constructHouse() {
houseBuilder.buildBasic();
houseBuilder.buildWalls();
houseBuilder.roofed();
return houseBuilder.buildHouse();
}
}
Client 类
public class Client {
public static void main(String[] args) {
CommonHouse commonHouse = new CommonHouse();
HouseDirector houseDirector = new HouseDirector(commonHouse);
houseDirector.constructHouse();
System.out.println("--------------------------");
HighBuilding highBuilding = new HighBuilding();
houseDirector.setHouseBuilder(highBuilding);
houseDirector.constructHouse();
}
}
除此之外，建造者模式在 JDK 中也有应用，JDK 中的 StringBuilder 类：
Appendable接口定义多个append方法(抽象方法)，即Appendable为抽象建造者，定义了抽象方法AbstractStringBuilder类实现了Appendable接口方法，这里的AbstractStringBuilder已经是建造者，但是不能实例化StringBuilder既充当了指挥者角色又充当了具体的建造者，建造方法的实现是由AbstractStringBuilder完成，而StringBuilder继承了AbstractStringBuilder