深入理解工厂模式：从简单工厂到抽象工厂

2025-06-06 03:55:51作者：仰钰奇

工厂模式概述

工厂模式是创建型设计模式中最常用的一种，它提供了一种将对象实例化过程封装起来的方式，使代码更加灵活和可维护。工厂模式的核心思想是将对象的创建与使用分离，让客户端代码不需要关心具体的实现类。

为什么需要工厂模式？

在软件开发中，我们经常会遇到需要创建对象的情况。直接使用new操作符创建对象虽然简单，但会带来几个问题：

代码耦合度高：客户端代码直接依赖具体实现类
难以扩展：当需要添加新的产品类型时，需要修改多处代码
违反开闭原则：对扩展开放，对修改关闭的原则难以实现

工厂模式正是为了解决这些问题而提出的解决方案。

工厂模式的三种形态

1. 简单工厂模式

简单工厂模式是最基础的形式，它通过一个工厂类来集中处理对象的创建逻辑。

特点：

一个工厂类负责所有产品的创建
通过参数决定创建哪种产品
不符合开闭原则（新增产品需要修改工厂类）

适用场景：

产品种类较少且不太可能变化
客户端不关心具体产品的创建过程

2. 工厂方法模式

工厂方法模式将对象的创建延迟到子类中，由子类决定实例化哪个类。

特点：

定义一个创建对象的接口，但由子类决定实例化的类
每个具体产品对应一个具体工厂
符合开闭原则

适用场景：

一个类不知道它所需要的对象的类
一个类希望由它的子类来指定它所创建的对象
将类的实例化延迟到子类

3. 抽象工厂模式

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

特点：

创建一组相关或相互依赖的对象
产品族的概念（多个产品系列）
易于交换产品系列

适用场景：

系统需要独立于其产品的创建、组合和表示
系统需要配置多个产品族中的一个
需要提供一个产品类库，只暴露接口而非实现

工厂模式实现详解

简单工厂模式实现

// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("执行产品A的操作");
    }
}

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        }
        // 可以扩展其他产品类型
        throw new IllegalArgumentException("不支持的产品类型");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product product = factory.createProduct("A");
        product.operation();
    }
}

工厂方法模式实现

// 抽象产品
interface Product {
    void operation();
}

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

// 具体产品A
class ProductA implements Product {
    @Override
    public void operation() {
        System.out.println("产品A的操作");
    }
}

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        Product product = factory.createProduct();
        product.operation();
    }
}

抽象工厂模式实现

// 抽象产品A
interface ProductA {
    void operationA();
}

// 抽象产品B
interface ProductB {
    void operationB();
}

// 具体产品A1
class ProductA1 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("产品A1的操作");
    }
}

// 具体产品B1
class ProductB1 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("产品B1的操作");
    }
}

// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();
        
        productA.operationA();
        productB.operationB();
    }
}