工厂模式（Factory Pattern）

工厂模式（Factory Pattern）是一种创建型设计模式，旨在封装对象的创建过程，通过工厂方法创建对象，而不是在代码中直接使用构造函数。

作用：

• 将对象的创建过程与使用者分离，客户端只需要通过工厂方法获取对象，无需了解具体的创建细节。
• 提供了一种灵活的方式来创建对象，可以根据需求动态地选择创建哪种类型的对象。

优势：

• 降低耦合度：使用工厂模式可以将对象的创建与使用解耦，客户端只与工厂接口交互，而不需要知道具体的实现类。
• 提供了扩展性：通过增加新的工厂实现类，可以轻松地扩展系统的功能，添加新的产品类型，而无需修改客户端代码。
• 封装复杂的创建逻辑：某些对象的创建过程可能非常复杂，包括多个步骤或依赖关系，工厂模式可以将这些复杂的创建逻辑封装在工厂中，提供简单的接口给客户端使用。

适用场景：

• 对象的创建过程复杂：当对象的创建涉及复杂的逻辑、依赖关系或多个步骤时，可以使用工厂模式来封装创建过程，使客户端代码更加简洁。
• 需要灵活扩展对象的创建：当需要在系统中动态添加新的产品类型，而不希望修改现有代码时，可以使用工厂模式来添加新的工厂实现类，实现对象的动态创建。

以下是一些常见的工厂模式的变体：

• 简单工厂模式：使用一个工厂类来创建不同类型的对象，根据传入的参数或条件判断来确定创建哪种类型的对象。
• 工厂方法模式：将对象的创建交给具体的工厂类，每个具体工厂类负责创建一种具体类型的对象，客户端通过调用不同的工厂方法来获取不同类型的对象。
• 抽象工厂模式：提供一个接口或抽象类，定义了一系列工厂方法，每个工厂方法负责创建一组相关的对象，客户端可以通过具体工厂类来创建一系列相关的对象。

工厂模式在很多场景中都有广泛的应用，特别是当需要将对象的创建过程封装起来，提供灵活性和扩展性时，工厂模式是一个常见且有效的设计模式。

代码举例说明

以下是简单工厂模式、工厂方法模式和抽象工厂模式的代码示例：

简单工厂模式：

// 抽象产品
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) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation();

        Product productB = SimpleFactory.createProduct("B");
        productB.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");
    }
}

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

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

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

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

抽象工厂模式：

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

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

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

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

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

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

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

//