Java工厂方法模式详解

工厂方法模式(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);

工厂方法模式的应用场景

  1. 对象创建逻辑复杂:例如数据库连接对象,需要配置参数、初始化资源等。
  2. 根据条件动态创建对象:例如游戏中根据关卡生成不同的敌人。
  3. 框架设计:例如 Java 的Calendar.getInstance()方法。
  4. 解耦对象创建与使用:提高代码可维护性,例如 Spring 框架的BeanFactory

优缺点

优点

  • 符合开闭原则:新增产品只需添加新的具体工厂类,无需修改基类。
  • 降低耦合度:将对象创建逻辑封装在工厂类中。
  • 提高代码可扩展性:便于引入新产品。

缺点

  • 类数量增加:每个具体产品都需要对应的具体工厂类。
  • 代码复杂度上升:简单场景可能过度设计。

与其他模式的对比

  1. 简单工厂 vs 工厂方法

    • 简单工厂:通过静态方法创建对象,不支持开闭原则。
    • 工厂方法:通过继承和多态实现对象创建,支持开闭原则。
  2. 工厂方法 vs 抽象工厂

    • 工厂方法:专注于创建单一产品。
    • 抽象工厂:创建一组相关产品(产品族),强调产品之间的依赖关系。

总结

工厂方法模式是创建型设计模式中最常用的模式之一,它通过将对象创建逻辑延迟到子类,实现了代码的可扩展性和可维护性。在实际开发中,根据场景选择合适的变体(如参数化工厂、反射工厂)可以进一步简化代码。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

勤奋的知更鸟

你的鼓励将是我创作的最大动力!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值