工厂模式详解

工厂模式在Java中的应用非常广泛，尤其是当需要将对象创建的细节与客户端代码分离时。它也是Java设计模式中常用的创建型模式之一。接下来，我将详细讲解如何在Java中使用工厂模式，包括简单工厂模式、工厂方法模式和抽象工厂模式。

1. 简单工厂模式（Simple Factory Pattern）

简单工厂模式通过一个静态方法，根据传入的参数创建不同的对象。这种模式的实现集中在一个工厂类中，工厂类负责决定创建哪个具体类的实例。
代码示例：

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

// 具体产品 A
class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品 B
class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        } else {
            return null;
        }
    }
}

// 使用者
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();  // 输出: 使用产品A

        Product productB = SimpleFactory.createProduct("B");
        productB.use();  // 输出: 使用产品B
    }
}

特点：
优点：对象创建逻辑集中在一个工厂类中，调用者只需传递参数来获取相应的对象，简单方便。
缺点：工厂类包含所有对象创建的逻辑，当需要增加新的产品时，必须修改工厂类的代码，违反了开放封闭原则。

2. 工厂方法模式（Factory Method Pattern）

工厂方法模式通过定义一个抽象工厂接口，将具体的产品创建交给子类来实现。这使得代码更具扩展性，每当有新的产品时，只需增加相应的工厂类和产品类即可，无需修改现有代码。
代码示例：

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

// 具体产品 A
class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品 B
class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

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

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

// 具体工厂 B
class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 使用者
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use();  // 输出: 使用产品A

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use();  // 输出: 使用产品B
    }
}

特点：

• 优点：遵循了开放封闭原则，可以通过扩展子类添加新产品，无需修改已有代码。每个工厂类只负责创建一种产品，职责单一。
• 缺点：当产品种类过多时，会导致工厂类的数量急剧增加，增加系统复杂度。

3. 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式是一种更高层次的工厂模式，它提供一个接口，用来创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂通常用于创建多个产品族。

代码示例：

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

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

// 具体产品 A1
class ProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用产品A1");
    }
}

// 具体产品 A2
class ProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用产品A2");
    }
}

// 具体产品 B1
class ProductB1 implements ProductB {
    @Override
    public void use() {
        System.out.println("使用产品B1");
    }
}

// 具体产品 B2
class ProductB2 implements ProductB {
    @Override
    public void use() {
        System.out.println("使用产品B2");
    }
}

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

// 具体工厂 1，负责创建 A1 和 B1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂 2，负责创建 A2 和 B2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 使用者
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();  // 输出: 使用产品A1
        productB1.use();  // 输出: 使用产品B1

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();  // 输出: 使用产品A2
        productB2.use();  // 输出: 使用产品B2
    }
}

特点：

• 优点：抽象工厂模式可以创建一系列相关的产品，确保产品之间的兼容性。新增产品族时，只需扩展具体工厂，不需要修改已有代码。
• 缺点：如果需要增加新的产品种类，所有的工厂类都需要修改，扩展性较差。

工厂模式的应用场景

工厂模式适用于以下场景：

• 当类不知道它所需的对象的具体类型时，可以使用工厂模式将对象的创建委托给子类或工厂类。
• 当对象创建过程比较复杂，可能涉及到多个依赖对象或多个步骤时，工厂模式可以封装复杂的创建过程。
• 当系统需要通过扩展来引入新产品时，使用工厂方法模式和抽象工厂模式能够避免修改现有代码，符合开放封闭原则。

总结

工厂模式在Java中的应用分为简单工厂模式、工厂方法模式和抽象工厂模式，它们各自适用于不同的场景：

• 简单工厂模式：适合处理少量产品，逻辑简单，但不易扩展。
• 工厂方法模式：每种产品对应一个工厂类，具有更好的扩展性。
• 抽象工厂模式：适用于创建一系列相关或互相依赖的产品族，能够保证产品的兼容性。

这些模式在实际开发中可以提高代码的可维护性和扩展性，有助于应对复杂的对象创建需求。