java设计模式：抽象工厂模式 + 建造者模式

1710orange2025-09-29 9:05

将抽象工厂模式与建造者模式结合，可以优雅地处理需要创建​​多个产品族​​，且每个产品族内部对象​​构建过程复杂​​的场景。这种结合充分发挥了抽象工厂管理产品族的优势，以及建造者模式精细控制复杂对象构建过程的优势

。

下面我们通过一个构建不同风格（现代、古典）房屋的例子来具体说明。

🧱 核心组件定义

首先，我们定义房屋的组成部分和不同风格的具体实现。

​​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("田园");
    }
    // ... 实现构建方法
}
相关推荐
代码不停10 小时前
Java前缀和算法题目练习
java·开发语言·算法
豆沙沙包?10 小时前
2025年--Lc200- 414. 第三大的数（大根堆）--Java版
java·开发语言
在下木子生10 小时前
SpringBoot基于工厂模式的多类型缓存设计
java·spring boot·缓存
xxxxxxllllllshi10 小时前
Java中Elasticsearch完全指南：从零基础到实战应用
java·开发语言·elasticsearch·面试·职场和发展·jenkins
无毁的湖光Al10 小时前
日常问题排查-Younggc突然变长
java·jvm·后端
_星辰大海乀10 小时前
网络原理 -- HTTP
java·服务器·http·get方法·post方法
bkspiderx11 小时前
C++设计模式之行为型模式：访问者模式（Visitor）
c++·设计模式·访问者模式
没有bug.的程序员11 小时前
电商系统分布式架构实战：从单体到微服务的演进之路
java·分布式·微服务·云原生·架构·监控体系·指标采集
Lei活在当下11 小时前
【业务场景架构实战】8. 订单状态流转在 UI 端的呈现设计
android·设计模式·架构
Query*11 小时前
Java 设计模式——代理模式：从静态代理到 Spring AOP 最优实现
java·设计模式·代理模式
热门推荐
01BongoCat - 跨平台键盘猫动画工具02GitHub 镜像站点03UV安装并设置国内源04Linux下V2Ray安装配置指南05两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答06KGG转MP3工具|非KGM文件|解密音频07windows找不到gpedit.msc（本地组策略编辑器）08荣耀手机2025年10月发布的新品Magic8比起Magic7，在硬件、性能、价格等上有什么区别，有什么优势09GitLab 零基础入门指南：从安装到项目管理全流程10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南