Java工厂方法模式详解

原创于 2025-05-31 16:49:51 发布 · 616 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#java #工厂方法模式 #开发语言

Java 专栏收录该内容

36 篇文章

订阅专栏

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它将对象的创建和使用分离，通过定义一个创建对象的接口，让子类决定实例化哪个类。这种模式提高了代码的可扩展性和可维护性，尤其适用于需要根据不同条件创建不同类型对象的场景。

核心概念

产品（Product）：定义产品的接口或抽象类。
具体产品（ConcreteProduct）：实现产品接口的具体类。
工厂（Creator）：声明创建产品的抽象方法（工厂方法）。
具体工厂（ConcreteCreator）：实现工厂方法，返回具体产品的实例。

简单工厂模式（静态工厂）

在介绍工厂方法模式前，先看一个简单工厂的实现：

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

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

class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Unsupported product type");
        }
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation(); // 输出: ConcreteProductA operation
    }
}

缺点：简单工厂违反了开闭原则（对扩展开放，对修改关闭）。新增产品时需要修改工厂类的逻辑。

工厂方法模式（标准实现）

工厂方法模式将创建逻辑延迟到子类，避免修改基类：

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

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

class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 抽象工厂
abstract class Creator {
    // 工厂方法
    public abstract Product factoryMethod();
    
    // 业务逻辑
    public void someOperation() {
        Product product = factoryMethod();
        product.operation();
    }
}

// 具体工厂A
class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        creatorA.someOperation(); // 输出: ConcreteProductA operation
        
        Creator creatorB = new ConcreteCreatorB();
        creatorB.someOperation(); // 输出: ConcreteProductB operation
    }
}

工厂方法模式的变体

1. 参数化工厂方法

通过参数指定创建的产品类型，将选择逻辑移至工厂类：

abstract class Creator {
    public Product createProduct(String type) {
        Product product = factoryMethod(type);
        // 其他初始化逻辑
        return product;
    }
    
    protected abstract Product factoryMethod(String type);
}

class ConcreteCreator extends Creator {
    @Override
    protected Product factoryMethod(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Unsupported type");
        }
    }
}

2. 使用反射的工厂

通过类名或 Class 对象动态创建产品，避免大量的条件判断：

class ReflectiveCreator {
    public <T extends Product> T createProduct(Class<T> clazz) {
        try {
            return clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Product creation failed", e);
        }
    }
}

// 使用示例
ReflectiveCreator creator = new ReflectiveCreator();
Product productA = creator.createProduct(ConcreteProductA.class);