如何选择最适合自己的工厂模式？从产品种类、数量、工厂数量角度出发！

在Java中，根据工厂模式的实现方式和用途，我们可以将工厂模式分为以下几种类型：

简单工厂模式

简单工厂模式（Simple Factory Pattern）是一种最基本的工厂模式，在该模式中，我们可以定义一个工厂类，用于创建不同类型的对象，并在调用时动态返回相应的对象。简单工厂模式通常只包含一个具体工厂类和多个具体产品类。

下面是一个简单工厂模式的示例代码：

// 抽象产品
interface Product {
    void doSomething();
}

// 具体产品A
class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product A is doing something.");
    }
}

// 具体产品B
class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product B is doing something.");
    }
}

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

// 示例用法
Product productA = SimpleFactory.createProduct("A");
productA.doSomething();

Product productB = SimpleFactory.createProduct("B");
productB.doSomething();

工厂方法模式

工厂方法模式（Factory Method Pattern）是一种用于创建对象的工厂模式，它将对象的创建过程抽象出来，具体的对象由子类来创建，从而实现了对象的多态性。工厂方法模式通常包含一个抽象工厂类和多个具体工厂类，每个工厂类都负责创建一种具体产品。

下面是一个工厂方法模式的示例代码：

// 抽象产品
interface Product {
    void doSomething();
}

// 具体产品A
class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product A is doing something.");
    }
}

// 具体产品B
class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product B is doing something.");
    }
}

// 抽象工厂
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();
    }
}

// 示例用法
Factory factoryA = new FactoryA();
Product productA = factoryA.createProduct();
productA.doSomething();

Factory factoryB = new FactoryB();
Product productB = factoryB.createProduct();
productB.doSomething();

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它可以创建一组相关或相互依赖的对象，并能够保证这些对象之间的兼容性。抽象工厂模式通常包含一个抽象工厂类和多个具体工厂类，每个具体工厂类负责创建一组相关的产品。

抽象工厂模式的优点在于，它可以通过抽象工厂类和具体工厂类之间的关系来隔离客户端与产品类之间的耦合度，从而使得系统更加灵活、可扩展和易于维护。

下面是一个抽象工厂模式的示例代码：

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

// 具体产品A1
class ProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("Product A1 is doing something.");
    }
}

// 具体产品A2
class ProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("Product A2 is doing something.");
    }
}

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

// 具体产品B1
class ProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("Product B1 is doing something.");
    }
}

// 具体产品B2
class ProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("Product B2 is doing something.");
    }
}

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

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

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

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

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

// 示例用法
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.doSomething();
productB1.doSomething();

AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.doSomething();
productB2.doSomething();

在上述代码中，我们首先定义了两个抽象产品接口ProductA和ProductB，并实现了多个具体产品类。然后，我们定义了一个抽象工厂接口AbstractFactory，其中包含了创建不同类型产品的方法。

接着，我们实现了两个具体工厂类ConcreteFactory1和ConcreteFactory2，每个工厂类负责创建一组相关的产品。最后，我们通过具体的工厂类来创建具体的产品对象，并调用其相应的方法。

需要注意的是，在实际开发中，我们还需要考虑众多细节问题，例如如何管理工厂对象、如何处理异常、如何进行参数校验等。同时，还需要结合具体的业务需求来选择不同的工厂模式（例如简单工厂、工厂方法、抽象工厂等），以满足系统的复杂性和可扩展性需求。

=========================================

如果文章对你有帮助，请加个关注、点个赞！！！