创建型设计模式详解

payload2025-03-29 18:19

创建型设计模式提供了创建对象的机制， 能够提升已有代码的灵活性和可复用性。

工厂模式

简单工厂模式

定义：通过一个工厂类，根据传入的参数动态决定创建哪种具体产品类的实例。

适用场景：产品种类较少且变化不频繁的场景。

结构

classDiagram class Product { <> +use() } class ConcreteProductA { +use() } class ConcreteProductB { +use() } class SimpleFactory { +createProduct(String type): Product } SimpleFactory --> Product : 创建 Product <|.. ConcreteProductA : 实现 Product <|.. ConcreteProductB : 实现

代码示例

java 复制代码 
// 抽象产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("未知产品类型");
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        productA.use(); // 输出：使用产品A
    }
}

工厂方法模式

定义：定义一个创建对象的接口，但由子类决定实例化哪个类。将对象的创建延迟到子类。

适用场景：需要支持多种产品类型且可能频繁扩展的场景。

结构

classDiagram class Product { <> +use() } class ConcreteProductA { +use() } class ConcreteProductB { +use() } class Factory { <> +createProduct(): Product } class ConcreteFactoryA { +createProduct(): Product } class ConcreteFactoryB { +createProduct(): Product } Factory <|-- ConcreteFactoryA : 继承 Factory <|-- ConcreteFactoryB : 继承 ConcreteFactoryA --> ConcreteProductA : 创建 ConcreteFactoryB --> ConcreteProductB : 创建 Product <|.. ConcreteProductA : 实现 Product <|.. ConcreteProductB : 实现

代码示例

java 复制代码 
// 抽象产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 抽象工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // 输出：使用产品A

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // 输出：使用产品B
    }
}

抽象工厂模式

定义：提供一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。

适用场景：需要创建一组相关或依赖对象的场景（如跨平台UI组件库）。

结构

classDiagram class AbstractFactory { <> +createButton(): Button +createTextField(): TextField } class WindowsFactory { +createButton(): WindowsButton +createTextField(): WindowsTextField } class MacFactory { +createButton(): MacButton +createTextField(): MacTextField } class Button { <> +render() } class WindowsButton { +render() } class MacButton { +render() } class TextField { <> +display() } class WindowsTextField { +display() } class MacTextField { +display() } AbstractFactory <|.. WindowsFactory : 实现 AbstractFactory <|.. MacFactory : 实现 Button <|.. WindowsButton : 实现 Button <|.. MacButton : 实现 TextField <|.. WindowsTextField : 实现 TextField <|.. MacTextField : 实现 WindowsFactory --> WindowsButton : 创建 WindowsFactory --> WindowsTextField : 创建 MacFactory --> MacButton : 创建 MacFactory --> MacTextField : 创建

代码示例

java 复制代码 
// 抽象产品族A
interface Button {
    void render();
}

// 具体产品A1：Windows按钮
class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染Windows风格按钮");
    }
}

// 具体产品A2：Mac按钮
class MacButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染Mac风格按钮");
    }
}

// 抽象产品族B
interface TextField {
    void display();
}

// 具体产品B1：Windows文本框
class WindowsTextField implements TextField {
    @Override
    public void display() {
        System.out.println("显示Windows风格文本框");
    }
}

// 具体产品B2：Mac文本框
class MacTextField implements TextField {
    @Override
    public void display() {
        System.out.println("显示Mac风格文本框");
    }
}

// 抽象工厂接口
interface GUIFactory {
    Button createButton();
    TextField createTextField();
}

// 具体工厂1：Windows工厂
class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public TextField createTextField() {
        return new WindowsTextField();
    }
}

// 具体工厂2：Mac工厂
class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public TextField createTextField() {
        return new MacTextField();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        GUIFactory windowsFactory = new WindowsFactory();
        Button winButton = windowsFactory.createButton();
        TextField winTextField = windowsFactory.createTextField();
        winButton.render();      // 输出：渲染Windows风格按钮
        winTextField.display();  // 输出：显示Windows风格文本框

        GUIFactory macFactory = new MacFactory();
        Button macButton = macFactory.createButton();
        TextField macTextField = macFactory.createTextField();
        macButton.render();      // 输出：渲染Mac风格按钮
        macTextField.display();  // 输出：显示Mac风格文本框
    }
}

工厂模式对比

模式 核心特点 扩展性 适用场景
简单工厂 单工厂类，通过参数创建不同产品 差（需修改工厂类） 产品类型少且不频繁变化
工厂方法 每个产品对应一个工厂子类 好（新增子类即可） 需要灵活扩展产品类型的场景
抽象工厂 生产多个相关产品组成的家族 中等（产品族难扩展） 需要保证产品兼容性的复杂系统

生成器设计模式

模式定义

生成器模式是一种创建型设计模式，用于分步骤构建复杂对象。它通过将对象的构建过程与其表示分离，使得相同的构建过程可以创建不同的对象表示。该模式特别适用于需要多个配置参数或构建步骤的对象，避免了冗长的构造函数参数列表（称为"重叠构造函数"问题），并提高了代码的可读性和灵活性。

核心角色

生成器模式包含以下关键角色：

角色 说明
产品（Product） 最终要构建的复杂对象，包含多个组成部分（如电脑的 CPU、内存、硬盘）。
生成器（Builder） 定义构建产品各部分的抽象接口（如 setCPU()、setRAM()）。
具体生成器（Concrete Builder） 实现生成器接口，提供构建各部分的具体逻辑，并返回最终产品。
指挥者（Director） 可选角色，负责调用生成器的步骤方法，控制构建流程（如组装电脑的标准流程）。

结构

classDiagram class Product { -cpu: String -ram: String -storage: String +toString(): String } class Builder { <> +buildCPU(String cpu): void +buildRAM(String ram): void +buildStorage(String storage): void +getResult(): Product } class ComputerBuilder { -product: Product +buildCPU(String cpu): void +buildRAM(String ram): void +buildStorage(String storage): void +getResult(): Product } class Director { -builder: Builder +construct(): void } Product <-- ComputerBuilder : 创建 Builder <|.. ComputerBuilder : 实现 Director --> Builder : 使用

代码示例

以"组装电脑"为例，演示生成器模式的应用：

java 复制代码 
// 步骤1：定义产品类（Computer）
public class Computer {
    private String cpu;
    private String ram;
    private String storage;

    public void setCpu(String cpu) { this.cpu = cpu; }
    public void setRam(String ram) { this.ram = ram; }
    public void setStorage(String storage) { this.storage = storage; }

    @Override
    public String toString() {
        return "Computer [CPU=" + cpu + ", RAM=" + ram + ", Storage=" + storage + "]";
    }
}

// 步骤2：定义生成器接口（ComputerBuilder）
public interface ComputerBuilder {
    void buildCPU(String cpu);
    void buildRAM(String ram);
    void buildStorage(String storage);
    Computer getResult();
}

// 步骤3：实现具体生成器（StandardComputerBuilder）
public class StandardComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCPU(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildRAM(String ram) {
        computer.setRam(ram);
    }

    @Override
    public void buildStorage(String storage) {
        computer.setStorage(storage);
    }

    @Override
    public Computer getResult() {
        return computer;
    }
}

// 步骤4：定义指挥者（Director，可选）
public class Director {
    private ComputerBuilder builder;

    public Director(ComputerBuilder builder) {
        this.builder = builder;
    }

    // 定义标准组装流程
    public void constructBasicComputer() {
        builder.buildCPU("Intel i5");
        builder.buildRAM("8GB DDR4");
        builder.buildStorage("512GB SSD");
    }

    public void constructHighEndComputer() {
        builder.buildCPU("AMD Ryzen 9");
        builder.buildRAM("32GB DDR5");
        builder.buildStorage("2TB NVMe SSD");
    }
}

// 步骤5：客户端使用
public class Client {
    public static void main(String[] args) {
        // 创建生成器
        ComputerBuilder builder = new StandardComputerBuilder();
        
        // 使用指挥者（可选）
        Director director = new Director(builder);
        director.constructBasicComputer();
        
        // 直接通过生成器构建（无指挥者）
        // builder.buildCPU("Intel i5");
        // builder.buildRAM("8GB DDR4");
        // builder.buildStorage("512GB SSD");
        
        // 获取最终产品
        Computer computer = builder.getResult();
        System.out.println(computer);  // 输出：Computer [CPU=Intel i5, RAM=8GB DDR4, Storage=512GB SSD]
    }
}

生成器模式的变体：链式生成器（Fluent Builder）

通过返回 this 实现链式调用，提升代码可读性：

java 复制代码 
public class Computer {
    private String cpu;
    private String ram;
    private String storage;

    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
    }

    public static class Builder {
        private String cpu;
        private String ram;
        private String storage;

        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder ram(String ram) {
            this.ram = ram;
            return this;
        }

        public Builder storage(String storage) {
            this.storage = storage;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

// 使用方式
Computer computer = new Computer.Builder()
    .cpu("Intel i7")
    .ram("16GB DDR4")
    .storage("1TB NVMe SSD")
    .build();

应用场景

生成器模式适用于以下场景：

  • 多参数对象构建：对象需要多个可选参数（如订单、用户配置）。
  • 复杂构建流程：对象构建涉及多个步骤（如生成PDF报告需设置页眉、正文、页脚）。
  • 避免重叠构造函数：替代多个重载的构造函数（如 new User(name, age, email, phone)）。
  • 构建不可变对象：通过生成器逐步设置参数后，返回不可变对象（如Java中的StringBuilder生成String）。

优缺点分析

优点 缺点
解耦构建过程与产品表示 增加代码复杂度（需定义生成器类）
支持分步骤构建和灵活配置 对简单对象可能过度设计
提高代码可读性和可维护性

生成器模式 vs 工厂模式

维度 生成器模式 工厂模式
核心目标 分步骤构建复杂对象 创建单一对象
适用场景 多参数、多步骤的对象构建 直接创建完整对象
代码复杂度 高（需定义生成器类） 低（直接调用工厂方法）
典型应用 StringBuilder、文档生成器 Calendar.getInstance()、Spring Bean

总结

生成器模式通过将复杂对象的构建过程分解为独立的步骤，提供了高度灵活性和可维护性。其核心价值在于：

  • 代码清晰：避免冗长的构造函数参数列表。

  • 灵活扩展：支持逐步构建和不同产品表示。

  • 解耦构建逻辑：分离构建过程与产品实现。

适用建议：

  • 当对象需要多个可选参数或构建步骤时，优先选择生成器模式。

  • 对于简单对象，直接使用构造函数或工厂方法即可。

后续内容更新中，请耐心等待

相关推荐
cooldream20096 小时前
深入理解MVP架构：让UI层与业务逻辑完美分离的设计模式
ui·设计模式·架构·系统架构师
摘星编程9 小时前
并发设计模式实战系列(3)：工作队列
设计模式·并发编程
Pasregret9 小时前
访问者模式：分离数据结构与操作的设计模式
数据结构·设计模式·访问者模式
Aniugel12 小时前
JavaScript高级面试题
javascript·设计模式·面试
不当菜虚困12 小时前
JAVA设计模式——（四）门面模式
java·开发语言·设计模式
Niuguangshuo12 小时前
Python设计模式：MVC模式
python·设计模式·mvc
Lei活在当下13 小时前
【现代 Android APP 架构】01. APP 架构综述
android·设计模式·架构
前端大白话13 小时前
震惊！90%前端工程师都踩过的坑！computed属性vs methods到底该怎么选？一文揭秘高效开发密码
前端·vue.js·设计模式
前端大白话13 小时前
前端必看！figure标签在响应式图片排版中的王炸操作，grid/flex布局实战指南
前端·设计模式·html
ApeAssistant13 小时前
Spring + 设计模式 （十四） 行为型 - 观察者模式
spring·设计模式
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU08苍穹外卖面试总结09yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）