Java创建型模式---工厂模式

工厂模式基础概念

工厂模式是一种创建型设计模式，其核心思想是将对象的创建和使用分离。通过使用工厂模式，可以将对象创建逻辑集中管理，提高代码的可维护性和可扩展性。在 Java 中，工厂模式主要分为三种类型：

1. 简单工厂模式 - 基础实现，不属于 GOF 23 种设计模式
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");
    }
}

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

// 客户端代码
public class SimpleFactoryClient {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation(); // 输出: ConcreteProductA operation
        
        Product productB = SimpleFactory.createProduct("B");
        productB.operation(); // 输出: ConcreteProductB operation
    }
}

优点：实现简单，将对象创建和使用分离
缺点：工厂类职责过重，不符合开闭原则（新增产品需修改工厂类）

工厂方法模式

工厂方法模式定义了一个创建对象的接口，让子类决定实例化哪个类。工厂方法将类的实例化延迟到子类。

示例代码

// 产品接口
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 Factory {
    public abstract Product createProduct();
}

// 具体工厂类A - 生产产品A
class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂类B - 生产产品B
class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryMethodClient {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation(); // 输出: ConcreteProductA operation
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation(); // 输出: ConcreteProductB operation
    }
}

优点：符合开闭原则，扩展性好
缺点：类的数量可能过多，增加系统复杂度

抽象工厂模式

抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。

示例代码

// 产品A接口
interface ProductA {
    void operationA();
}

// 产品B接口
interface ProductB {
    void operationB();
}

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

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operationA");
    }
}

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

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB2 operationB");
    }
}

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

// 具体工厂1 - 生产产品A1和产品B1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2 - 生产产品A2和产品B2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class AbstractFactoryClient {
    public static void main(String[] args) {
        // 使用工厂1创建产品族1
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.operationA(); // 输出: ConcreteProductA1 operationA
        productB1.operationB(); // 输出: ConcreteProductB1 operationB
        
        // 使用工厂2创建产品族2
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.operationA(); // 输出: ConcreteProductA2 operationA
        productB2.operationB(); // 输出: ConcreteProductB2 operationB
    }
}

优点：

• 可以在类的内部对产品族中相关联的多等级产品共同管理
• 客户端始终只使用一个工厂的对象
• 符合开闭原则

缺点：

• 产品族扩展困难（新增一个产品需要修改多个接口和类）
• 实现复杂

三种工厂模式的对比

工厂模式的应用场景

1. 对象创建逻辑复杂 - 当对象创建过程涉及复杂的初始化逻辑时
2. 根据条件动态创建对象 - 如根据配置或用户输入创建不同类型的对象
3. 产品等级结构管理 - 当系统需要处理多个产品族时

注意事项

1. 避免过度使用 - 简单场景下无需使用工厂模式
2. 权衡设计复杂度 - 选择合适的工厂模式类型
3. 与其他模式结合 - 工厂模式常与单例模式、策略模式等结合使用

工厂模式是一种非常实用的设计模式，它能够将对象的创建和使用分离，提高代码的可维护性和可扩展性。在实际应用中，需要根据具体场景选择合适的工厂模式实现。