创建型设计模式详解

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

总结

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

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

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

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

适用建议：

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

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

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

相关推荐
coderzpw1 小时前
设计模式中的“万能转换器”——适配器模式
设计模式·适配器模式
三金C_C8 小时前
单例模式解析
单例模式·设计模式·线程锁
ShareBeHappy_Qin10 小时前
设计模式——设计模式理念
java·设计模式
木子庆五11 小时前
Android设计模式之代理模式
android·设计模式·代理模式
前端_ID林13 小时前
前端必须知道的设计模式
设计模式
麦客奥德彪16 小时前
设计模式分类与应用指南
设计模式
小宋要上岸16 小时前
设计模式-单例模式
单例模式·设计模式
程序员JerrySUN16 小时前
设计模式 Day 1：单例模式（Singleton Pattern）详解
单例模式·设计模式
古力德18 小时前
代码重构之[过长参数列表]
设计模式·代码规范
OpenSeek20 小时前
【设计模式】面向对象的设计模式概述
设计模式·c#·设计原则
热门推荐
01【笔记】MJ Prompt02DeepSeek各版本说明与优缺点分析03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04uniApp使用XR-Frame创建3D场景(3)光源投影的运用。05RAG 实践- Ollama+RagFlow 部署本地知识库06如何在WPS和Word/Excel中直接使用DeepSeek功能07【通信中间件】Fdbus HelloWorld实例08苍穹外卖面试总结09DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具10HTML项目一键打包工具：HTML2EXE 最新版