彻底分清简单，工厂，抽象工厂模式+优化

1. 简单工厂模式（静态工厂模式）

根据客户端传入指定产品的参数，通过工厂类判断该参数，直接返回相应的具体产品向上转型对象；
角色：
抽象产品A：与客户端交互的抽象产品；
具体产品：实现抽象产品的ProductA1 ,ProductA2，
简单工厂：客户端根据工厂方法传入向的参数返回具体产品；

interface ProductA{}
class ProductA1 implements  ProductA{}
class ProductA2 implements  ProductA{}
class SimpleFactory{
    public static ProductA getProduct(String category){
        if (category.equals("a1")){
            return new ProductA1();
        }
        if (category.equals("a2")){
            return new ProductA2();
        }
        return null;
    }
}

简单工厂方法实现了客户端与具体产品实现的解耦，通过抽象出抽象产品，一定程度上提高了程序的可拓展性。当我们需要添加第三种子产品时，我们只需要在工厂类增加返回相应产品的代码，客户端并不需要修改原来的代码；
虽然如此，我们需要修改工厂类代码，依然是违背了开闭原则（对拓展开放，对修改关闭）；
而工厂模式则是完全遵循了开闭原则；

2. 工厂模式

工厂模式通过依赖倒转原则，面向接口设计，实现在不修改原来的代码的同时，对功能实现拓展；

角色：
抽象产品：（定义抽象接口，提高拓展性）
具体产品：ProductA1，ProductA2
抽象工厂：定义创建抽象产品
具体工厂：具体共产与具体产品一一，实现抽象工厂，创建具体产品；

interface Factory{
    ProductA createProductA();
}
class  FactoryA1 implements Factory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
}
class  FactoryA2 implements Factory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
}

工厂方法将创建具体产品的过程封装到具体工厂当中，这使得选择哪种具体产品的判断也就交个了客户端；这也是与简单工厂方法的区别之一；
不管是简单工厂方法还是工厂方法，都应对的是只用一种抽象产品的场景；
如果存在两种抽象产品，以上方法或许可以通过复制一份的方法实现，但是复制往往是最糟糕的设计，所以抽象工厂方法便提供了更优解；

3. 抽象工厂模式

与工厂模式相比，抽象模式下的抽象工厂抽象的就是多种抽象产品创建过程，而不再是一种了；
角色：
抽象产品：ProductA,ProductB
具体产品：ProductA1,ProductB1, ProductA2,ProductB2(可以假设是产品版本)
抽象工厂：IFactory
具体工厂：Factory1,Factory2，具体工厂会提供创建两种产品的方法；

/////抽象工厂/////
interface ProductB{}
class ProductB1 implements ProductB{};
class ProductB2 implements ProductB{};

interface IFactory{
    ProductA createProductA();
    ProductB createProductB();
}
class Factory1 implements IFactory{

    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}
class Factory2 implements IFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

以上工厂的方法的客户端实现：

public class Client {
    public static void main(String[] args) {
        //simple
        ProductA a1 = SimpleFactory.getProduct("a1");

        //factory
        Factory factory =  new FactoryA1();
        ProductA factoryA1 = factory.createProductA();
        factory = new FactoryA2();
        ProductA productA2 = factory.createProductA();

        //abstract 
        IFactory absFactory = new Factory1();
        ProductA pa1 = absFactory.createProductA();
        ProductB pb1 = absFactory.createProductB();
        absFactory = new Factory2();
        ProductA pa2 = absFactory.createProductA();
        ProductB pb2 = absFactory.createProductB();
    }
}

抽象工厂方法解决了工厂方法只能创建一种抽象产品的问题，使用了抽象工厂模式创建了获取了具体产品后，如果需要更换比如使用升级产品，我们只需要在客户端更改抽象共产的创建代码；从一定程度上集中了我们修改代码的工作量。
但是，如果客户端在多处都使用了抽象工厂模式创建对象呢？一百个地方使用到了，我们就需要修改一百个地方，所以我们可以通过以下方式优化抽象工厂模式；

4. 利用反射+配置优化抽象工厂模式

通过配置的获取客户端具体想要的产品版本，在使用反射的代码创建具体的产品；代替了抽象工厂和具体工厂创建具体产品的过程；

/**
 * 使用反射 + 配置方式获取产品版本号；代替IFactory，Factory1, Factory2
 */
public class OptimiseAbstractFactory {
     @Value("A_VERSION")
    String A_VERSION;
    
    @Value("B_VERSION")
    String B_VERSION;

  
    public ProductA getProductA(){
        ProductA pro=null;
        String clzName = "com.ed.gof.abstractFactory.ProductA"+A_VERSION;
        try {
            Class<?> proClz = Class.forName(clzName);
            pro = (ProductA) proClz.newInstance();
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }
        return pro;
    }
    public ProductB getProductB(){
        ProductB pro=null;
        String clzName = "com.ed.gof.abstractFactory.ProductB"+B_VERSION;
        try {
            Class<?> proClz = Class.forName(clzName);
            pro = (ProductB) proClz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return pro;
    }
    //client
  public static void main(String[] args) {
        Optimistic optimistic = new Optimistic();
        ProductA productA = optimistic.getProductA();
        ProductB productB = optimistic.getProductB();
        productA.functionA();productB.functionB();
    }
}

总：
从简单工厂到工厂模式是遵循了开闭原则，从工厂模式的抽象工厂模式是实现对多个抽象产品的场景应用，优化方法则避免多处修改，并且实现了可配置；