工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，定义一个创建对象的接口或抽象类，让其子类来决定实例化哪一个具体类。这样可以将对象的创建与使用分离开来，增加了系统的灵活性和可维护性。 例如，有一个产品接口，多个具体产品实现该接口，然后有一个工厂类，根据不同的条件来创建相应的具体产品对象。

优点包括：

• 解耦了产品的创建和使用。
• 方便扩展产品类，无需修改使用产品的代码。
• 可以集中管理对象的创建逻辑。

《设计模式》一书中，工厂模式被分为了三种：简单工厂、工厂方法和抽象工厂。（不过，在书中作者将简单工厂模式看作是工厂方法模式的一种特例。）

接下来我会介绍三种工厂模式的原理及使用

• 简单工厂模式（不属于GOF的23种经典设计模式）
• 工厂方法模式
• 抽象工厂模式

简单工厂：

在不考虑任何代码的可扩展性的前提下,只为了尽快满足需求.我们可以这样去设计这个业务的代码结构

interface Product {
    void doSomething();
}

class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA is doing something");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB is doing something");
    }
}

class SimpleFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

public class SimpleFactoryExample {
    public static void main(String[] args) {
      
        // 不同的产品做什么事情
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        productA.doSomething();

        Product productB = factory.createProduct("B");
        productB.doSomething();
    }
}

工厂方法模式：

为了提高代码扩展性,我们需要将简单工厂中的if分支逻辑去掉,通过增加抽象工厂(生产工厂的工厂)的方式,让具体工厂去进行实现,由具体工厂来决定实例化哪一个具体的产品对象.

interface Product {
    void doSomething();
}

class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA is doing something");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB is doing something");
    }
}


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

//工厂A继承抽象工厂 **具体工厂**
class ConcreteFactoryA extends Factory {
    @Override
    Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB extends Factory {
    @Override
    Product createProduct() {
        return new ConcreteProductB();
    }
}

public class FactoryMethodExample {
    public static void main(String[] args) {
      
        // 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
        //在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，
        //无须对原工厂进行任何修改，满足开闭原则；
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.doSomething();

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

抽象工厂模式

在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法,用于产生多种不同类型的产品.这些产品构成了一个产品族.

interface ProductA {
    void doSomethingA();
}

interface ProductB {
    void doSomethingB();
}

class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomethingA() {
        System.out.println("ConcreteProductA1 is doing something A");
    }
}

class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomethingA() {
        System.out.println("ConcreteProductA2 is doing something A");
    }
}

class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomethingB() {
        System.out.println("ConcreteProductB1 is doing something B");
    }
}

class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomethingB() {
        System.out.println("ConcreteProductB2 is doing something B");
    }
}

interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

public class AbstractFactoryExample {
    public static void main(String[] args) {
      
      //对于不同产品系列有比较多共性特征时，可以使用抽象工厂模式，有助于提升组件的复用性.
      //当需要提升代码的扩展性并降低维护成本时，把对象的创建和使用过程分开，
         // 能有效地将代码统一到一个级别上
        //解决跨平台带来的兼容性问题
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.doSomethingA();
        productB1.doSomethingB();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.doSomethingA();
        productB2.doSomethingB();
    }
}

抽象工厂模式比工厂方法模式的抽象程度更高. 在工厂方法模式中每一个具体工厂只需要生产一种具体产品,但是在抽象工厂模式中一个具体工厂可以生产一组相关的具体产品,这样一组产品被称为产品族.产品族中的每一个产品都分属于某一个产品继承等级结构.

在使用工厂模式时候需要注意：

简单工厂模式：

• 工厂类可能会变得庞大和复杂，当产品种类较多时维护成本可能增加。
• 不利于扩展新的产品类型，如果添加新产品可能需要修改工厂类。

工厂方法模式：

• 可能会导致系统中类的数量增多，增加一定的复杂性。
• 对于每个具体工厂类，需要确保其创建逻辑的正确性和稳定性。

抽象工厂模式：

• 难以应对产品族结构的频繁变化，扩展较为困难。
• 增加新的产品族可能需要较大的改动。

总体来说，无论哪种工厂模式，都需要在设计时充分考虑系统的扩展性、可维护性和灵活性，根据具体需求合理选择和运用。同时，要注意保持代码的清晰和简洁，避免过度设计导致不必要的复杂性。