在日常开发中,如果遇到日常需求为:
①需要建房子:过程为打地基、砌墙、封顶;
②能够实现不同类型房子对建造过程的复用。
那么我们应该如何实现这个需求呢?首先我们先画出UML的关系图如下:
以一个抽象类作为父类,抽象的声明建造房子的方法,具体实现类则作为子类来实现抽象类,Client类则负责创建。
//抽象父类
public abstract class AbstractBuilding {
public abstract void base();
public abstract void wall();
public abstract void roof();
public void build(){
base();
wall();
roof();
}
}
//具体实现类
public class CommonBuilding extends AbstractBuilding{
@Override
public void base() {
System.out.println("普楼打地基");
}
@Override
public void wall() {
System.out.println("普楼砌墙");
}
@Override
public void roof() {
System.out.println("普楼封顶");
}
}
//具体实现类
public class HighBuilding extends AbstractBuilding{
@Override
public void base() {
System.out.println("高楼打地基");
}
@Override
public void wall() {
System.out.println("高楼砌墙");
}
@Override
public void roof() {
System.out.println("高楼封顶");
}
}
public class Client {
public static void main(String[] args) {
CommonBuilding commonBuilding = new CommonBuilding();
commonBuilding.build();
HighBuilding highBuilding = new HighBuilding();
highBuilding.build();
}
}
这种写法的有点是简单易懂,可是这种程序结构简单,扩展与维护起来较困难,耦合性比较强。
于是我们使用建造者模式替代。
对建造者模式的基本介绍:
1.它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。
2.建造者模式 是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节
建造者模式的四个角色:
- Product(产品角色): 一个具体的产品对象。
- Builder(抽象建造者): 创建一个Product对象的各个部件指定的 接口/抽象类。
- ConcreteBuilder(具体建造者): 实现接口,构建和装配各个部件。
- Director(指挥者): 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用,一是:隔离了客户与对象的生产过程,二是:负责控制产品对象的生产过程。
UML关系图如下:
Building是产品,将其封装为一个Bean
public class Building {
private String base;
private String wall;
private String roof;
public String getBase() {
return base;
}
public void setBase(String base) {
this.base = base;
}
public String getWall() {
return wall;
}
public void setWall(String wall) {
this.wall = wall;
}
public String getRoof() {
return roof;
}
public void setRoof(String roof) {
this.roof = roof;
}
}
Builder类作为抽象类,内部声明产品与抽象方法:
//抽象的建造者
public abstract class Builder {
protected Building building = new Building();
//抽象建造的流程
public abstract void baseBuild();
public abstract void wallBuild();
public abstract void roofBuild();
//返回房子
public Building getBuilding(){
return building;
}
}
CommonBuilding类作为具体实现类,继承Builder父类,实现抽象父类的方法(同为实现类的HighBuilding写法一致,这里省略):
public class CommonBuilding extends Builder{
@Override
public void baseBuild() {
System.out.println("普楼打地基——小型");
}
@Override
public void wallBuild() {
System.out.println("普楼砌墙——小型");
}
@Override
public void roofBuild() {
System.out.println("普楼封顶——小型");
}
}
建造指挥官,通过传入Builder对象,调用对象实现具体方法,仅仅负责实现建造的步骤,不关心建造的具体实现,返回最终产品:
public class BuildingDirector {
Builder builder = null;
//构造器传入
public BuildingDirector(Builder builder){
this.builder = builder;
}
//setter方法传入
public void setBuilder(Builder builder) {
this.builder = builder;
}
//指挥者负责建造的过程管控
public Building constructBuilding(){
builder.baseBuild();
builder.wallBuild();
builder.roofBuild();
return builder.getBuilding();
}
}
客户端调用:
public class Client {
public static void main(String[] args) {
CommonBuilding commonBuilding = new CommonBuilding();
BuildingDirector buildingDirector = new BuildingDirector(commonBuilding);
//产品房子
Building building = buildingDirector.constructBuilding();
}
}
总结
掌握建造者模式需要记住建造者模式的四个角色,每个角色有每个角色负责的内容,达到解耦的实际效果。