将抽象工厂模式与建造者模式结合，可以优雅地处理需要创建多个产品族，且每个产品族内部对象构建过程复杂的场景。这种结合充分发挥了抽象工厂管理产品族的优势，以及建造者模式精细控制复杂对象构建过程的优势
。
下面我们通过一个构建不同风格（现代、古典）房屋的例子来具体说明。
🧱 核心组件定义
首先，我们定义房屋的组成部分和不同风格的具体实现。
1. 产品部件接口
定义门、窗、屋顶等部件的通用接口。
java
// 门接口
public interface Door {
void install();
String getStyle();
}
// 窗接口
public interface Window {
void install();
String getStyle();
}
// 屋顶接口
public interface Roof {
void build();
String getStyle();
}2. 具体产品部件
实现现代风格和古典风格的具体部件。
java
// 现代风格门
public class ModernDoor implements Door {
@Override public void install() { System.out.println("安装现代风格门：简洁线条，玻璃元素"); }
@Override public String getStyle() { return "现代"; }
}
// 古典风格门
public class ClassicalDoor implements Door {
@Override public void install() { System.out.println("安装古典风格门：雕花装饰，实木材质"); }
@Override public String getStyle() { return "古典"; }
}
// 现代风格窗
public class ModernWindow implements Window {
@Override public void install() { System.out.println("安装现代风格窗：大面积玻璃，极简窗框"); }
@Override public String getStyle() { return "现代"; }
}
// 古典风格窗
public class ClassicalWindow implements Window {
@Override public void install() { System.out.println("安装古典风格窗：繁复窗格，装饰性窗棂"); }
@Override public String getStyle() { return "古典"; }
}
// 现代风格屋顶
public class ModernRoof implements Roof {
@Override public void build() { System.out.println("建造现代风格屋顶：平顶设计，可作露台"); }
@Override public String getStyle() { return "现代"; }
}
// 古典风格屋顶
public class ClassicalRoof implements Roof {
@Override public void build() { System.out.println("建造古典风格屋顶：坡面设计，琉璃瓦"); }
@Override public String getStyle() { return "古典"; }
}🏭 抽象工厂模式应用：创建产品族
抽象工厂负责创建一整套风格一致的产品部件。
1. 抽象工厂接口
java
public interface HouseComponentFactory {
Door createDoor();
Window createWindow();
Roof createRoof();
}2. 具体工厂
实现现代风格和古典风格的具体工厂。
java
// 现代风格工厂
public class ModernComponentFactory implements HouseComponentFactory {
@Override public Door createDoor() { return new ModernDoor(); }
@Override public Window createWindow() { return new ModernWindow(); }
@Override public Roof createRoof() { return new ModernRoof(); }
}
// 古典风格工厂
public class ClassicalComponentFactory implements HouseComponentFactory {
@Override public Door createDoor() { return new ClassicalDoor(); }
@Override public Window createWindow() { return new ClassicalWindow(); }
@Override public Roof createRoof() { return new ClassicalRoof(); }
}🏗️ 建造者模式应用：组装复杂房屋
建造者模式负责将部件一步步组装成完整的房屋对象
。
1. 产品：房屋
java
public class House {
private Door door;
private Window window;
private Roof roof;
private String style;
public void setDoor(Door door) { this.door = door; }
public void setWindow(Window window) { this.window = window; }
public void setRoof(Roof roof) { this.roof = roof; }
public void setStyle(String style) { this.style = style; }
public void display() {
System.out.println("\n=== " + style + "风格房屋建造完成 ===");
door.install();
window.install();
roof.build();
System.out.println("房屋整体风格协调性检查通过！");
}
}2. 抽象建造者
java
public abstract class HouseBuilder {
protected House house = new House();
public abstract void buildDoor();
public abstract void buildWindow();
public abstract void buildRoof();
public House getHouse() { return house; }
}3. 具体建造者
java
// 现代房屋建造者
public class ModernHouseBuilder extends HouseBuilder {
private HouseComponentFactory factory;
public ModernHouseBuilder() {
this.factory = new ModernComponentFactory(); // 使用现代风格工厂
house.setStyle("现代");
}
@Override public void buildDoor() { house.setDoor(factory.createDoor()); }
@Override public void buildWindow() { house.setWindow(factory.createWindow()); }
@Override public void buildRoof() { house.setRoof(factory.createRoof()); }
}
// 古典房屋建造者
public class ClassicalHouseBuilder extends HouseBuilder {
private HouseComponentFactory factory;
public ClassicalHouseBuilder() {
this.factory = new ClassicalComponentFactory(); // 使用古典风格工厂
house.setStyle("古典");
}
@Override public void buildDoor() { house.setDoor(factory.createDoor()); }
@Override public void buildWindow() { house.setWindow(factory.createWindow()); }
@Override public void buildRoof() { house.setRoof(factory.createRoof()); }
}4. 指挥者
java
public class HouseDirector {
public House constructHouse(HouseBuilder builder) {
builder.buildDoor(); // 第一步：安装门
builder.buildWindow(); // 第二步：安装窗
builder.buildRoof(); // 第三步：建造屋顶
return builder.getHouse();
}
}👨💻 客户端使用
java
public class Client {
public static void main(String[] args) {
HouseDirector director = new HouseDirector();
// 建造现代风格房屋
HouseBuilder modernBuilder = new ModernHouseBuilder();
House modernHouse = director.constructHouse(modernBuilder);
modernHouse.display();
// 建造古典风格房屋
HouseBuilder classicalBuilder = new ClassicalHouseBuilder();
House classicalHouse = director.constructHouse(classicalBuilder);
classicalHouse.display();
// 动态选择风格
String preference = "modern"; // 可从配置读取
HouseBuilder builder = preference.equals("modern") ?
new ModernHouseBuilder() : new ClassicalHouseBuilder();
House dynamicHouse = director.constructHouse(builder);
dynamicHouse.display();
}
}✨ 模式结合的优势
这种结合使用的方式带来了显著的好处：
优势
说明
双重解耦
客户端与具体产品创建、组装过程均解耦，只需关心最终产品。
强一致性保证
抽象工厂确保部件风格一致，建造者确保组装顺序正确。
极高的扩展性
新增产品族（如田园风格）只需增加新工厂和建造者，符合开闭原则。
构建流程复用
HouseDirector中的构建算法可复用于任何风格的房屋建造。
精细控制
建造者模式允许对构建步骤进行精细控制，抽象工厂确保部件质量。
🔄 扩展新的产品族
增加一个"田园风格"产品族非常容易：
新增产品部件：创建 RusticDoor, RusticWindow, RusticRoof
新增抽象工厂实现：创建 RusticComponentFactory
新增具体建造者：创建 RusticHouseBuilder
扩展代码示例：
java
// 田园风格门
public class RusticDoor implements Door {
@Override public void install() { System.out.println("安装田园风格门：原木材质，自然纹理"); }
@Override public String getStyle() { return "田园"; }
}
// 田园风格工厂
public class RusticComponentFactory implements HouseComponentFactory {
@Override public Door createDoor() { return new RusticDoor(); }
@Override public Window createWindow() { return new RusticWindow(); } // 需实现RusticWindow
@Override public Roof createRoof() { return new RusticRoof(); } // 需实现RusticRoof
}
// 田园房屋建造者
public class RusticHouseBuilder extends HouseBuilder {
public RusticHouseBuilder() {
this.factory = new RusticComponentFactory();
house.setStyle("田园");
}
// ... 实现构建方法
}