ARTICLE DETAIL

建站实战干货

来自一线的建站与推广经验沉淀，每一条都经过真实交付验证。

首页 / 资讯中心 / 正文

工厂方法模式详解：原理、实现与应用场景

2026/8/12 12:55:40 拓冰建站 浏览量
工厂方法模式详解：原理、实现与应用场景

1. 工厂方法模式的核心思想

工厂方法模式（Factory Method）是一种创建型设计模式，它定义了一个用于创建对象的接口，但让子类决定实例化哪一个类。这种模式的核心在于将对象的实例化过程推迟到子类中进行，而不是在父类中直接实例化具体类。

想象一下你去餐厅点餐的场景。当你点一份披萨时，服务员（客户端）并不需要知道披萨具体是如何制作的，他只需要把订单交给厨房（工厂）。而厨房会根据订单类型决定是制作意大利披萨还是美式披萨。这个厨房就是我们的工厂方法，它封装了对象创建的复杂性。

工厂方法模式主要解决以下问题：

  • 一个类无法预知它需要创建哪个类的对象
  • 一个类希望由其子类来指定它所创建的对象
  • 需要将创建对象的职责委托给多个帮助子类中的某一个

2. 工厂方法模式的结构解析

2.1 模式参与者

工厂方法模式通常包含以下几个关键角色：

  1. Product（抽象产品）：定义工厂方法所创建的对象的接口
  2. ConcreteProduct（具体产品）：实现Product接口的具体类
  3. Creator（抽象创建者）：声明工厂方法，该方法返回一个Product类型的对象
  4. ConcreteCreator（具体创建者）：重写工厂方法以返回一个ConcreteProduct实例

2.2 UML类图表示

[Creator] |___ factoryMethod(): Product |___ anOperation() [ConcreteCreator] |___ factoryMethod(): Product [Product] |___ interface() [ConcreteProduct] |___ interface()

2.3 代码示例结构

// 抽象产品 interface Product { void operation(); } // 具体产品A class ConcreteProductA implements Product { @Override public void operation() { System.out.println("ConcreteProductA operation"); } } // 具体产品B class ConcreteProductB implements Product { @Override public void operation() { System.out.println("ConcreteProductB operation"); } } // 抽象创建者 abstract class Creator { // 工厂方法 abstract Product factoryMethod(); public void anOperation() { Product product = factoryMethod(); product.operation(); } } // 具体创建者A class ConcreteCreatorA extends Creator { @Override Product factoryMethod() { return new ConcreteProductA(); } } // 具体创建者B class ConcreteCreatorB extends Creator { @Override Product factoryMethod() { return new ConcreteProductB(); } }

3. 工厂方法模式的实现细节

3.1 参数化工厂方法

工厂方法可以有多种变体，其中一种常见的是参数化工厂方法。在这种变体中，工厂方法接收一个参数，根据这个参数决定创建哪种产品。

abstract class Creator { // 参数化工厂方法 abstract Product factoryMethod(String type); } class ConcreteCreator extends Creator { @Override Product factoryMethod(String type) { switch (type) { case "A": return new ConcreteProductA(); case "B": return new ConcreteProductB(); default: throw new IllegalArgumentException("Unknown product type"); } } }

3.2 使用类对象作为工厂方法参数

在Java等支持反射的语言中，可以使用Class对象作为工厂方法的参数：

abstract class Creator { abstract Product factoryMethod(Class<? extends Product> productClass); } class ConcreteCreator extends Creator { @Override Product factoryMethod(Class<? extends Product> productClass) { try { return productClass.newInstance(); } catch (Exception e) { throw new RuntimeException("Failed to create product", e); } } }

3.3 工厂方法模式与简单工厂的区别

很多初学者容易混淆工厂方法模式和简单工厂模式。它们的核心区别在于：

  • 简单工厂：由一个工厂类根据传入的参数决定创建哪种产品
  • 工厂方法：定义一个创建对象的接口，让子类决定实例化哪个类

简单工厂把全部创建逻辑集中在一个类中，而工厂方法则将创建逻辑分散到各个子类中。

4. 工厂方法模式的实际应用场景

4.1 框架设计中的应用

工厂方法模式在框架设计中非常常见。例如，在Java的集合框架中，java.util.Collection接口定义了iterator()方法，这就是一个工厂方法。具体的集合类（如ArrayList、HashSet）实现了这个方法，返回适合自己数据结构的迭代器。

public interface Collection<E> { Iterator<E> iterator(); // 其他方法... } public class ArrayList<E> implements Collection<E> { @Override public Iterator<E> iterator() { return new Itr(); // 返回ArrayList特有的迭代器 } // 其他实现... }

4.2 跨平台UI开发

在跨平台UI框架中，工厂方法模式可以用来创建平台特定的UI组件。例如：

// 抽象产品：按钮 interface Button { void render(); void onClick(); } // 具体产品：Windows按钮 class WindowsButton implements Button { @Override public void render() { System.out.println("Render Windows style button"); } @Override public void onClick() { System.out.println("Windows button clicked"); } } // 具体产品：MacOS按钮 class MacOSButton implements Button { @Override public void render() { System.out.println("Render MacOS style button"); } @Override public void onClick() { System.out.println("MacOS button clicked"); } } // 抽象创建者 abstract class Dialog { abstract Button createButton(); public void render() { Button button = createButton(); button.render(); button.onClick(); } } // 具体创建者：Windows对话框 class WindowsDialog extends Dialog { @Override Button createButton() { return new WindowsButton(); } } // 具体创建者：MacOS对话框 class MacOSDialog extends Dialog { @Override Button createButton() { return new MacOSButton(); } }

4.3 数据库访问层

在数据库访问层中，工厂方法可以用来创建不同类型的数据库连接：

interface Connection { void connect(); void executeQuery(String query); } class MySQLConnection implements Connection { @Override public void connect() { System.out.println("Connecting to MySQL database"); } @Override public void executeQuery(String query) { System.out.println("Executing MySQL query: " + query); } } class OracleConnection implements Connection { @Override public void connect() { System.out.println("Connecting to Oracle database"); } @Override public void executeQuery(String query) { System.out.println("Executing Oracle query: " + query); } } abstract class ConnectionFactory { abstract Connection createConnection(); } class MySQLConnectionFactory extends ConnectionFactory { @Override Connection createConnection() { return new MySQLConnection(); } } class OracleConnectionFactory extends ConnectionFactory { @Override Connection createConnection() { return new OracleConnection(); } }

5. 工厂方法模式的优缺点分析

5.1 优势

  1. 松耦合：客户端代码只需要知道抽象产品接口，不需要关心具体实现类
  2. 可扩展性：添加新产品时只需添加新的具体工厂类，无需修改现有代码
  3. 单一职责原则：将产品创建逻辑集中在一个地方，便于维护
  4. 开闭原则：对扩展开放（可以引入新的产品类型），对修改关闭（不需要修改现有代码）

5.2 局限性

  1. 类数量增加：每增加一个产品，通常需要增加一个具体工厂类
  2. 抽象性增加：需要引入额外的抽象层，增加了系统的复杂度
  3. 客户端必须知道具体工厂类：虽然客户端不需要知道具体产品类，但它需要知道使用哪个具体工厂类

5.3 适用场景评估

工厂方法模式特别适用于以下场景：

  • 一个类无法预知它必须创建的对象的类
  • 一个类希望由其子类来指定它所创建的对象
  • 需要将类的实例化延迟到子类中
  • 需要提供灵活的、可扩展的对象创建机制

6. 工厂方法模式的变体与扩展

6.1 并行类层次结构

工厂方法模式常常与并行类层次结构一起使用。在这种结构中，一个类层次结构中的类在另一个类层次结构中具有对应的工厂类。

[Shape] [ShapeFactory] |___ [Circle] |___ [CircleFactory] |___ [Rectangle] |___ [RectangleFactory] |___ [Triangle] |___ [TriangleFactory]

6.2 模板方法模式与工厂方法模式的结合

工厂方法模式经常与模板方法模式结合使用。模板方法定义算法的骨架，而将某些步骤的实现推迟到子类中。工厂方法可以作为这些推迟步骤的一种实现方式。

abstract class Application { // 模板方法 public final void run() { Document doc = createDocument(); // 工厂方法 doc.open(); doc.save(); doc.close(); } // 工厂方法 abstract Document createDocument(); } class WordProcessor extends Application { @Override Document createDocument() { return new WordDocument(); } } class Spreadsheet extends Application { @Override Document createDocument() { return new SpreadsheetDocument(); } }

6.3 使用Lambda表达式简化工厂方法

在Java 8及更高版本中，可以使用Lambda表达式或方法引用来简化工厂方法的实现：

interface ProductFactory { Product create(); } public class Client { private static final Map<String, ProductFactory> factories = new HashMap<>(); static { factories.put("A", ConcreteProductA::new); factories.put("B", ConcreteProductB::new); } public static Product createProduct(String type) { ProductFactory factory = factories.get(type); if (factory == null) { throw new IllegalArgumentException("Unknown product type"); } return factory.create(); } }

7. 工厂方法模式的最佳实践

7.1 设计考虑事项

  1. 工厂方法的访问级别：通常声明为protected，这样只有子类可以重写它
  2. 空工厂方法：有时可以提供一个默认实现返回null或默认对象
  3. 参数化工厂方法：当需要基于不同条件创建不同对象时很有用
  4. 命名约定：工厂方法通常命名为createXXX()或newXXX()

7.2 性能考量

虽然工厂方法模式提供了灵活性，但在性能敏感的场景中需要注意：

  1. 对象创建开销：频繁创建对象可能影响性能，考虑使用对象池
  2. 反射开销：如果使用反射实现工厂方法，要注意反射的性能影响
  3. 缓存机制：对于创建成本高的对象，可以在工厂中实现缓存

7.3 测试策略

工厂方法模式使得单元测试更加容易：

  1. 产品接口测试：可以针对抽象产品接口编写测试
  2. 模拟对象：在测试客户端代码时，可以轻松注入模拟产品
  3. 工厂子类测试：每个具体工厂可以单独测试其创建的产品
// 测试示例 @Test public void testConcreteCreatorA() { Creator creator = new ConcreteCreatorA(); Product product = creator.factoryMethod(); assertTrue(product instanceof ConcreteProductA); } @Test public void testProductOperation() { Product product = new ConcreteProductA(); product.operation(); // 验证操作结果 }

8. 工厂方法模式与其他模式的比较

8.1 工厂方法 vs 抽象工厂

工厂方法模式和抽象工厂模式都用于创建对象，但它们有不同的侧重点：

  • 工厂方法：创建单一产品，通过子类化来决定具体实例
  • 抽象工厂：创建产品家族，不需要子类化

工厂方法通常用于单个产品的创建，而抽象工厂用于创建相关或依赖对象的家族。

8.2 工厂方法 vs 建造者模式

工厂方法和建造者模式都创建对象，但它们的关注点不同：

  • 工厂方法：关注的是创建什么对象（what）
  • 建造者模式：关注的是如何创建复杂对象（how）

工厂方法通常用于创建单一、相对简单的对象，而建造者模式用于创建具有多个部分的复杂对象。

8.3 工厂方法 vs 原型模式

工厂方法和原型模式都是创建型模式，但它们的实现方式不同：

  • 工厂方法：通过子类化来创建新对象
  • 原型模式：通过克隆现有对象来创建新对象

原型模式适用于创建成本高的对象，或者需要避免使用new关键字的情况。

9. 工厂方法模式在实际项目中的经验分享

9.1 避免过度设计

虽然工厂方法模式提供了灵活性，但并不是所有情况都需要使用它。在实际项目中，应该根据以下标准决定是否使用工厂方法：

  1. 对象创建逻辑是否复杂或可能变化？
  2. 是否需要支持多种产品类型？
  3. 系统是否需要独立于其产品的创建、组合和表示？

如果答案都是"否"，那么可能简单直接的new操作符就足够了。

9.2 处理产品初始化

工厂方法不仅负责创建对象，还可以负责初始化对象。这是一个常见的实践：

abstract class Creator { abstract Product factoryMethod(); protected void initializeProduct(Product product) { // 默认初始化逻辑 product.setDefaultConfig(); } } class ConcreteCreator extends Creator { @Override Product factoryMethod() { Product product = new ConcreteProduct(); initializeProduct(product); product.setSpecificConfig(); // 特定初始化 return product; } }

9.3 处理创建异常

对象创建可能会失败，工厂方法应该妥善处理这些异常情况：

abstract class Creator { abstract Product factoryMethod() throws ProductCreationException; } class ConcreteCreator extends Creator { @Override Product factoryMethod() throws ProductCreationException { try { return new ConcreteProduct(); } catch (Exception e) { throw new ProductCreationException("Failed to create product", e); } } }

9.4 日志和监控

在工厂方法中添加适当的日志和监控可以帮助调试和性能分析：

abstract class Creator { private static final Logger logger = LoggerFactory.getLogger(Creator.class); abstract Product factoryMethod(); public Product create() { long startTime = System.currentTimeMillis(); Product product = factoryMethod(); long duration = System.currentTimeMillis() - startTime; logger.debug("Created {} in {} ms", product.getClass().getSimpleName(), duration); monitorCreation(product.getClass(), duration); return product; } protected abstract void monitorCreation(Class<? extends Product> productClass, long duration); }

10. 工厂方法模式的现代应用

10.1 在依赖注入框架中的应用

现代依赖注入（DI）框架如Spring、Guice等广泛使用了工厂方法的概念。例如，Spring中的@Bean注解实际上就是声明了一个工厂方法：

@Configuration public class AppConfig { @Bean public DataSource dataSource() { // 工厂方法实现 return new HikariDataSource(); } }

10.2 在函数式编程中的应用

在函数式编程中，工厂方法可以表示为高阶函数：

// JavaScript示例 function createProductFactory(productType) { switch (productType) { case 'A': return () => new ProductA(); case 'B': return () => new ProductB(); default: throw new Error('Unknown product type'); } } const factoryA = createProductFactory('A'); const productA = factoryA();

10.3 在微服务架构中的应用

在微服务架构中，工厂方法模式可以用于创建不同类型的服务客户端：

interface ServiceClient { void callService(); } class RestServiceClient implements ServiceClient { @Override public void callService() { // REST调用实现 } } class GrpcServiceClient implements ServiceClient { @Override public void callService() { // gRPC调用实现 } } interface ServiceClientFactory { ServiceClient createClient(); } class RestServiceClientFactory implements ServiceClientFactory { @Override public ServiceClient createClient() { return new RestServiceClient(); } } class GrpcServiceClientFactory implements ServiceClientFactory { @Override public ServiceClient createClient() { return new GrpcServiceClient(); } }

11. 工厂方法模式的替代方案

虽然工厂方法模式非常有用，但在某些情况下，其他方法可能更合适：

11.1 服务定位器模式

当对象创建需要从外部配置或运行时决定时，服务定位器模式可能是更好的选择：

class ServiceLocator { private static final Map<String, Supplier<Product>> factories = new HashMap<>(); static { register("A", ConcreteProductA::new); register("B", ConcreteProductB::new); } public static void register(String type, Supplier<Product> factory) { factories.put(type, factory); } public static Product create(String type) { Supplier<Product> factory = factories.get(type); if (factory == null) { throw new IllegalArgumentException("Unknown product type"); } return factory.get(); } }

11.2 依赖注入

在大型应用程序中，依赖注入通常比直接使用工厂方法更灵活：

class Client { private final Product product; @Inject public Client(Product product) { this.product = product; } public void doSomething() { product.operation(); } }

11.3 静态工厂方法

有时，简单的静态工厂方法就足够了：

class ProductFactory { public static Product createProduct(String type) { switch (type) { case "A": return new ConcreteProductA(); case "B": return new ConcreteProductB(); default: throw new IllegalArgumentException("Unknown product type"); } } }

12. 工厂方法模式的性能优化

12.1 对象池技术

对于创建成本高的对象，可以结合对象池技术：

abstract class PooledCreator { private final Queue<Product> pool = new LinkedList<>(); abstract Product createNew(); public Product getProduct() { if (pool.isEmpty()) { return createNew(); } return pool.poll(); } public void releaseProduct(Product product) { pool.offer(product); } }

12.2 延迟初始化

对于不总是需要的产品，可以实现延迟初始化：

abstract class LazyCreator { private Product product; abstract Product createProduct(); public Product getProduct() { if (product == null) { product = createProduct(); } return product; } }

12.3 缓存策略

缓存已创建的产品可以提高性能：

abstract class CachingCreator { private final Map<String, Product> cache = new HashMap<>(); abstract Product createProduct(String key); public Product getProduct(String key) { return cache.computeIfAbsent(key, this::createProduct); } }

13. 工厂方法模式的反模式与常见错误

13.1 过度使用工厂方法

不是所有对象创建都需要使用工厂方法。过度使用会导致代码复杂化，增加维护成本。

13.2 违反单一职责原则

如果工厂方法不仅创建对象，还包含复杂的业务逻辑，就违反了单一职责原则。

13.3 忽略异常处理

工厂方法应该妥善处理对象创建过程中可能出现的异常，而不是简单地抛出运行时异常。

13.4 循环依赖

当具体工厂和具体产品之间存在循环依赖时，会导致设计问题。应该通过重构来消除这种循环。

14. 工厂方法模式的演进与未来

14.1 在云原生应用中的演变

在云原生和Serverless架构中，工厂方法模式演变为更动态的对象提供方式，如通过服务网格或函数即服务（FaaS）来实现。

14.2 与容器技术的结合

现代容器技术（如Docker）和编排系统（如Kubernetes）可以被视为更高层次的工厂方法实现，它们动态地创建和管理服务实例。

14.3 在AI和机器学习中的应用

在机器学习系统中，工厂方法模式可以用于创建不同类型的模型或处理器，根据输入数据动态选择最合适的实现。

15. 工厂方法模式的代码重构技巧

15.1 将构造器替换为工厂方法

当发现直接使用构造器不够灵活时，可以重构为工厂方法：

重构前：

class Client { private Product product; public Client(String type) { if ("A".equals(type)) { product = new ProductA(); } else { product = new ProductB(); } } }

重构后：

class Client { private Product product; public Client(Product product) { this.product = product; } // 静态工厂方法 public static Client create(String type) { Product product; if ("A".equals(type)) { product = new ProductA(); } else { product = new ProductB(); } return new Client(product); } }

15.2 将简单工厂升级为工厂方法

当简单工厂变得难以维护时，可以升级为工厂方法：

重构前：

class ProductFactory { public static Product createProduct(String type) { switch (type) { case "A": return new ProductA(); case "B": return new ProductB(); default: throw new IllegalArgumentException(); } } }

重构后：

interface ProductFactory { Product createProduct(); } class ProductAFactory implements ProductFactory { @Override public Product createProduct() { return new ProductA(); } } class ProductBFactory implements ProductFactory { @Override public Product createProduct() { return new ProductB(); } }

15.3 合并相似的工厂方法

当发现多个工厂方法逻辑相似时，可以考虑合并：

重构前：

class CreatorA { Product createProduct() { return new ProductA(); } } class CreatorB { Product createProduct() { return new ProductB(); } }

重构后（使用参数化工厂方法）：

class UnifiedCreator { Product createProduct(String type) { switch (type) { case "A": return new ProductA(); case "B": return new ProductB(); default: throw new IllegalArgumentException(); } } }

16. 工厂方法模式在不同语言中的实现差异

16.1 Java中的实现

Java中的工厂方法通常使用抽象类和接口来实现：

// 使用抽象类 abstract class Creator { abstract Product factoryMethod(); } // 使用接口 interface Creator { Product factoryMethod(); }

16.2 Python中的实现

Python的鸭子类型使得工厂方法的实现更加灵活：

from abc import ABC, abstractmethod class Creator(ABC): @abstractmethod def factory_method(self): pass def some_operation(self): product = self.factory_method() return f"Creator: {product.operation()}" class ConcreteCreator1(Creator): def factory_method(self): return ConcreteProduct1() class ConcreteProduct1: def operation(self): return "Result of ConcreteProduct1"

16.3 JavaScript/TypeScript中的实现

JavaScript可以使用函数或类来实现工厂方法：

// 使用类 class Creator { factoryMethod() { throw new Error("factoryMethod must be implemented"); } } class ConcreteCreator extends Creator { factoryMethod() { return new ConcreteProduct(); } } // 使用函数 function createProduct(type) { const creators = { 'A': () => new ProductA(), 'B': () => new ProductB() }; const creator = creators[type]; if (!creator) { throw new Error(`Unknown product type: ${type}`); } return creator(); }

16.4 C++中的实现

C++中的工厂方法通常使用虚函数：

class Product { public: virtual ~Product() {} virtual std::string Operation() const = 0; }; class Creator { public: virtual ~Creator() {}; virtual Product* FactoryMethod() const = 0; std::string SomeOperation() const { Product* product = this->FactoryMethod(); std::string result = "Creator: " + product->Operation(); delete product; return result; } }; class ConcreteCreator : public Creator { public: Product* FactoryMethod() const override { return new ConcreteProduct(); } };

17. 工厂方法模式的测试策略

17.1 单元测试工厂方法

测试工厂方法是否返回正确的产品类型：

@Test public void testConcreteCreatorAFactoryMethod() { Creator creator = new ConcreteCreatorA(); Product product = creator.factoryMethod(); assertTrue(product instanceof ConcreteProductA); }

17.2 集成测试产品使用

测试工厂创建的产品在实际使用中的行为：

@Test public void testProductOperation() { Creator creator = new ConcreteCreatorA(); Product product = creator.factoryMethod(); String result = product.operation(); assertEquals("Expected result", result); }

17.3 性能测试

测试工厂方法的性能，特别是当创建过程复杂时：

@Test public void testFactoryMethodPerformance() { Creator creator = new ConcreteCreatorA(); long startTime = System.nanoTime(); for (int i = 0; i < 1000; i++) { creator.factoryMethod(); } long duration = System.nanoTime() - startTime; assertTrue(duration < TimeUnit.SECONDS.toNanos(1)); }

17.4 模拟测试

使用模拟对象测试依赖于工厂方法的客户端代码：

@Test public void testClientWithMockProduct() { Product mockProduct = mock(Product.class); when(mockProduct.operation()).thenReturn("Mock result"); Creator mockCreator = mock(Creator.class); when(mockCreator.factoryMethod()).thenReturn(mockProduct); Client client = new Client(mockCreator); String result = client.doSomething(); assertEquals("Mock result", result); }

18. 工厂方法模式的文档化建议

18.1 类图文档

为工厂方法模式创建清晰的类图，展示各个角色及其关系。

18.2 序列图文档

绘制序列图展示客户端如何通过工厂方法获取和使用产品：

[Client] -> [Creator] : factoryMethod() [Creator] -> [ConcreteProduct] : new() [Creator] --> [Client] : Product [Client] -> [Product] : operation()

18.3 使用示例文档

提供完整的代码示例，展示如何实现和使用工厂方法模式：

// 示例代码展示如何创建和使用工厂 Creator creator = new ConcreteCreatorA(); Product product = creator.factoryMethod(); product.operation();

18.4 模式选择理由文档

在文档中说明为什么选择工厂方法模式，而不是其他创建型模式。

19. 工厂方法模式在开源项目中的应用实例

19.1 Java集合框架中的Iterator

Java集合框架中的iterator()方法是一个典型的工厂方法：

List<String> list = new ArrayList<>(); Iterator<String> iterator = list.iterator(); // 工厂方法

19.2 Spring框架中的BeanFactory

Spring框架的BeanFactory接口及其实现使用了工厂方法的概念：

public interface BeanFactory { Object getBean(String name) throws BeansException; // 其他方法... }

19.3 JUnit中的TestRule

JUnit中的TestRule接口及其实现也使用了工厂方法模式：

public interface TestRule { Statement apply(Statement base, Description description); } public class TemporaryFolder implements TestRule { @Override public Statement apply(Statement base, Description description) { return new Statement() { @Override public void evaluate() throws Throwable { // 实现逻辑 } }; } }

19.4 React中的组件工厂

在React中，组件可以看作产品，而组件工厂用于创建这些组件：

function createComponent(type) { switch (type) { case 'button': return Button; case 'input': return Input; default: throw new Error(`Unknown component type: ${type}`); } } const Component = createComponent('button'); return <Component />;

20. 工厂方法模式的进阶思考

20.1 工厂方法与控制反转

工厂方法模式是实现控制反转（IoC）的一种方式。它将对象创建的主动权从客户端转移到工厂中。

20.2 工厂方法与依赖注入

依赖注入（DI）可以看作是工厂方法模式的一种演进。DI容器本质上是一个超级工厂，负责创建和管理所有对象。

20.3 工厂方法与领域驱动设计

在领域驱动设计（DDD）中，工厂方法模式可以用于实现领域对象的创建逻辑，保持领域模型的纯净性。

20.4 工厂方法与微服务架构

在微服务架构中，服务客户端工厂可以根据服务发现机制动态创建适当的客户端实现。

20.5 工厂方法与函数式编程

在函数式编程中，工厂方法可以表现为高阶函数，接收参数并返回特定的函数实现。