建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
建造者模式包含如下角色:
- Builder:抽象建造者
- ConcreteBuilder:具体建造者
- Director:指挥者
- Product:产品角色
以组装一台计算机为主,主要进行组装主机,设置操作系统,设置显示器。
计算机抽象类 Computer
public abstract class Computer {
protected String mBoard;
protected String mDisplay;
protected String mOs;
protected Computer(){
}
public abstract void setOs() ;
public void setBoard(String board){
mBoard=board;
}
public void setDisplay(String display) {
this.mDisplay = display;
}
@Override
public String toString() {
return "Computer{" +
"mBoard='" + mBoard + '\'' +
", mDisplay='" + mDisplay + '\'' +
", mOs='" + mOs + '\'' +
'}';
}
}
具体产品类 MacBook
public class MacBook extends Computer{
protected MacBook() {
}
@Override
public void setOs() {
mOs="Mac OS X 12";
}
}
抽象 Builder
public abstract class Builder {
abstract void buildBoard(String board);
abstract void buildDisplay(String display);
abstract void buildOs();
abstract Computer build();
}
具体的 Builder
public class MacBookBuilder extends Builder {
private Computer mComputer=new MacBook();
@Override
void buildBoard(String board) {
mComputer.setBoard(board);
}
@Override
void buildDisplay(String display) {
mComputer.setDisplay(display);
}
@Override
void buildOs() {
mComputer.setOs();
}
@Override
Computer build() {
return mComputer;
}
}
Director类,负责具体的构造 Computer
public class Director {
Builder mBuilser=null;
public Director(Builder builer) {
this.mBuilser = builer;
}
public void construct(String board,String display){
mBuilser.buildDisplay(display);
mBuilser.buildBoard(board);
mBuilser.buildOs();
}
}
具体使用
public class Test {
public static void main(String[] args){
Builder builder=new MacBookBuilder();
Director pcDirector=new Director(builder);
pcDirector.construct("英特尔主板","Retina显示器");
Computer computer = builder.build();
System.out.println(computer.toString());
}
}
输出:
总结:为了灵活构造复杂对象,该对象会有多个成员变量,在外部调用的时候,不需要或者不方便一次性创建出所有的成员变量,在这种情况下,使用多个构造方法去构建对象,很难维护,这时候Builder设计模式解决这个问题,进行buid()方法中创建对象,并且将builder传入,该builder中,维护了传入对象的成员变量。