1. 构建者模式
构建者模式是创建型的设计模式，可以将复杂对象的创建过程和表示分离，使得同样的构建过程可以创建不同的表示。构建者模式包括以下四种角色。
产品（Product）：是被构建的对象，是包含多个组件的复杂结构。
抽象建造者（Builder）：为创建的产品对象规定抽象接口，一般包括两类方法，一类是创建组件的方法（以build开头），一类是返回创建的对象的方法。
具体建造者（ConcreteBuilder）：实现建造者接口，实现各个部件的具体构造和装配方法。
导演者（Director）：负责指挥复杂对象的构建次序。
2. 构建者模式举例
游戏里的玩家形象的设定，可能包括了角色、服饰、坐骑、武器；不同玩家可能会选择不同的形象，这些形象的创建过程是大同小异的，需要逐步创建组成部分，再将不同的部分装配成完整的玩家形象。
| 序号 | 类名 | 角色 | 说明 |
|---|---|---|---|
| 1 | Actor | 产品 | 玩家形象 |
| 2 | ActorBuilder | 抽象建造者 | 玩家抽象构建者 |
| 3 | ActorDirector | 导演类 | 指挥对象构建次序 |
| 4 | SwordmanBuilder | 具体建造者 | 剑客 |
| 5 | WizardBuilder | 具体建造者 | 魔法师 |
| 6 | BuilderMain | 客户端 | 调用发起者 |
1. Actor
/**
* 产品类，玩家
*/
public class Actor {
private String role; // 角色
private String clothing; // 服饰
private String mount; // 坐骑
private String weapon; // 武器
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public String getClothing() {
return clothing;
}
public void setClothing(String clothing) {
this.clothing = clothing;
}
public String getMount() {
return mount;
}
public void setMount(String mount) {
this.mount = mount;
}
public String getWeapon() {
return weapon;
}
public void setWeapon(String weapon) {
this.weapon = weapon;
}
@Override
public String toString() {
return "Actor{" +
"role='" + role + '\'' +
", clothing='" + clothing + '\'' +
", mount='" + mount + '\'' +
", weapon='" + weapon + '\'' +
'}';
}
}
2. ActorBuilder
/**
* 抽象构建者类，玩家构建者
*/
public interface ActorBuilder {
void buildRole();
void buildClothing();
void buildMount();
void buildWeapon();
Actor buildActor();
}
3. ActorDirector
/**
* 导演类
*/
public class ActorDirector {
private ActorBuilder builder;
public ActorDirector(ActorBuilder builder) {
this.builder = builder;
}
/**
* 构建玩家对象
* @return Actor
*/
public Actor construct() {
builder.buildRole();
builder.buildClothing();
builder.buildMount();
builder.buildWeapon();
return builder.buildActor();
}
}
4. SwordmanBuilder
/**
* 具体构建者，剑客
*/
public class SwordmanBuilder implements ActorBuilder {
private Actor swordman = new Actor();
@Override
public void buildRole() {
System.out.println("构建玩家角色：剑侠客");
swordman.setRole("剑侠客");
}
@Override
public void buildClothing() {
System.out.println("构建玩家角色：长衫");
swordman.setClothing("长衫");
}
@Override
public void buildMount() {
System.out.println("构建玩家坐骑：麒麟");
swordman.setMount("麒麟");
}
@Override
public void buildWeapon() {
System.out.println("构建玩家武器：长剑");
swordman.setWeapon("长剑");
}
@Override
public Actor buildActor() {
return swordman;
}
}
5. WizardBuilder
/**
* 魔法师构建者
*/
public class WizardBuilder implements ActorBuilder {
private Actor wizard = new Actor();
@Override
public void buildRole() {
System.out.println("构建玩家角色：魔法师");
wizard.setRole("魔法师");
}
@Override
public void buildClothing() {
System.out.println("构建玩家角色：长袍斗篷");
wizard.setClothing("长袍斗篷");
}
@Override
public void buildMount() {
System.out.println("构建玩家坐骑：白霜战马");
wizard.setMount("白霜战马");
}
@Override
public void buildWeapon() {
System.out.println("构建玩家武器：魔法杖");
wizard.setWeapon("魔法杖");
}
@Override
public Actor buildActor() {
return wizard;
}
}
6. BuilderMain
/**
* 客户端
*/
public class BuilderMain {
public static void main(String[] args) {
// 构建剑侠客对象
ActorBuilder builder = new SwordmanBuilder();
ActorDirector director = new ActorDirector(builder);
Actor swordman = director.construct();
System.out.println(swordman);
// 构建魔法师对象
ActorBuilder wizardBuilder = new WizardBuilder();
director = new ActorDirector(wizardBuilder);
Actor wizard = director.construct();
System.out.println(wizard);
}
}
3. 构建者模式总结
有的时候，Director角色可以省略，合并到抽象Builder类中。
优点：
客户端不知道产品内部的组成细节，将产品本身和产品的创建过程解耦，使用相同的创建过程可以创建不同的产品对象。每一个具体建造者都相对独立，而与其他的具体建造者无关。
缺点：建造者模式所创建的产品一般具有较多的共同点，如果产品之间差异大，可能就不适用创建者模式；或者导致代码变得复杂，难以理解。
（完）
