You need to enable JavaScript to run this app. 简单工厂与工厂方法模式对比:为何要使用工厂方法?
优惠活动
大模型
产品
解决方案
定价
更多

简单工厂与工厂方法模式对比:为何要使用工厂方法?

简单工厂与工厂方法的核心差异

我正在学习设计模式,目前接触到工厂类相关模式,已经理解简单工厂与工厂方法的概念与运行逻辑,但始终无法厘清工厂方法相比简单工厂的核心优势,以下是我编写的示例:

// 定义基础类
public class Animal {}
public class Dog extends Animal{}
public class Cat extends Animal{}

简单工厂实现

public Animal getAnimal(String type) {
    switch (type) {
    case "cat": 
      return new Cat();
    case "dog":
      return new Dog();
    }
    return null;
}

自行编写的工厂方法实现

public abstract class AnimalFactory {
   public Animal createAnimal() {
       Animal animal = getAnimal();
       animal.pet();
       return animal;
   }
  
   protected abstract Animal getAnimal();
}

public class DogFactory extends AnimalFactory{
   public Animal getAnimal(){
      // 自定义实例化逻辑
      return new Dog();
   }
}

public class CatFactory extends AnimalFactory{
   public Animal getAnimal(){
      // 自定义实例化逻辑
      return new Cat();
   }
}

核心困惑

使用工厂方法时虽然用到了多态,但仍然需要根据所需的类型来实例化对应工厂,因此我推测实际使用时会写成这样的形式:

public Animal getAnimal(String type) {
    AnimalFactory animalFactory;
    switch (type) {
    case "cat": 
      animalFactory = new CatFactory();  // 多态实现     
      return animalFactory.getAnimal();
    case "dog":
       animalFactory = new DogFactory();  // 多态     
      return animalFactory.getAnimal();
    }
    return null;
}

据我所知,设计模式的核心目标是提升代码复用性、简化扩展流程。假设需要新增动物类型Parrot,两种实现场景下都需要:

  • 创建继承自Animal的Parrot类
  • 修改上述switch分支语句,新增case "Parrot"分支:简单工厂中直接实例化Parrot对象,工厂方法中则实例化ParrotFactory对象

我的疑问是:两种实现到底有什么区别?为什么还需要使用工厂方法模式?
目前我能看到的唯一优势是,工厂方法可以在抽象父类中为所有继承它的子类工厂定义通用逻辑,是不是只有这个优势?


实际解答

首先要明确:你觉得两者没区别,核心是你把工厂方法的使用场景用成了简单工厂的套壳。
工厂方法的设计前提,从来不是要求你写一个带参数判断的统一入口,去根据类型选择对应工厂——这种写法本身就是对模式的误用。

两种模式的封装边界本质不同

  • 简单工厂的核心是把所有产品的实例化逻辑集中在同一个类/方法里,客户端完全不需要知道具体产品类的存在,传参数就能拿对象。整个逻辑的耦合点,全在那个集中的switch块里。
  • 工厂方法的核心是把每一个产品的实例化逻辑拆成独立的子类,而调用这些工厂的客户端代码,本身是明确知道自己需要哪类产品的——业务代码要什么产品,就直接依赖对应的工厂类,全程不需要写任何类型判断逻辑。

举个实际的业务场景:宠物商店的犬类业务模块,直接依赖DogFactory创建实例;猫类业务模块,直接依赖CatFactory创建实例。这种场景下,你根本不需要那个接收String类型的getAnimal(String type)方法,自然也就不存在需要反复修改switch分支的问题。

工厂方法的实际优势远不止父类通用逻辑

你观察到的"父类提取公共逻辑"只是最表层的特性,核心差异体现在三个维度:

  1. 对开闭原则的友好度天差地别
    简单工厂的所有判断逻辑挤在同一个switch块里,新增产品就必须修改这个核心方法,哪怕只是加一个case,也需要把整个类的测试重新跑一遍,漏写break、返回null这类低级bug的风险始终存在。
    标准工厂方法模式下,新增Parrot类型时,你只需要新增Parrot产品类和对应的ParrotFactory工厂类,不需要改动任何已有的业务代码、已有的工厂代码——因为本来就没有那个集中的switch判断块。哪怕后续要做配置化的工厂映射(比如通过依赖注入把所有工厂注册成类型到实例的Map),新增工厂也只是加配置的事,不需要改动核心判断逻辑。
  2. 复杂初始化逻辑的隔离性完全不同
    简单工厂的switch块里,每个case如果涉及复杂初始化(比如创建Dog时需要查询用户偏好、加载品种数据、关联组装配套物品),这些逻辑会全部堆在同一个方法里,很快就会膨胀成几百行的难维护代码。
    工厂方法把每个产品的初始化逻辑完全隔离在对应的子类工厂里:Dog的初始化逻辑在DogFactory,Cat的在CatFactory,每个类职责单一,单元测试的时候也可以单独mock对应工厂,不需要把整个简单工厂的所有依赖全部拉满。
  3. 扩展灵活性不在一个层级
    简单工厂只能返回单一抽象产品的实例,如果后续要扩展成"一个工厂生成同一系列的多个关联产品"(比如Dog配套的狗窝、狗粮,Cat配套的猫窝、猫砂),简单工厂的代码会快速膨胀成多维度的switch嵌套。
    工厂方法可以非常平滑地升级成抽象工厂:只要在抽象工厂里新增多个产品生成方法,每个具体工厂负责生成一整个系列的产品,完全不需要改动客户端的调用逻辑。

你写的"工厂方法套switch"到底是什么

你之前实现的那个带switch的工厂选择逻辑,本质是把简单工厂和工厂方法组合出来的"工厂路由器",这种写法在特定场景下确实存在,但和纯工厂方法的定位完全不同:
这个路由器的作用不是实现核心的产品实例化,而是把所有具体工厂的初始化逻辑,从零散的客户端代码里抽离出来,形成统一的注册入口。这种场景下,新增Parrot的时候虽然还是要修改switch,但修改的内容已经从"写具体的new Parrot()逻辑",变成了"把ParrotFactory注册到映射关系里",修改的影响范围、出错的风险,和简单工厂直接改产品实例化逻辑是完全不在一个量级的。

最后补充一个常见误区:
工厂方法从来不是简单工厂的"强制升级替代版"。如果产品类型很少、初始化逻辑非常简单,用简单工厂是最高效的选择,没必要为了套设计模式硬写一堆工厂子类,徒增代码量。只有当产品类型不断增多、每个产品的初始化逻辑越来越复杂、后续还要扩展关联产品时,工厂方法的优势才会真正体现出来。


内容的提问来源于stack exchange,提问作者user924941

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.10.27 17:24:03