简单工厂模式违背了开闭原则，而工厂模式是对简单工厂的进一步抽象。好处是可以使系统在不修改原来代码的情况下生产新的产品，满足开闭原则。

优点：

1. 用户只需要知道具体工厂的名称就可以得到所要的产品，无需知道创建过程
2. 灵活性增强，想增加新产品，只需多写一个相应的工厂类
3. 典型的解耦框架，高层模块只需要知道产品的抽象类，无需关心其他实现类，满足迪米特法则，依赖倒置原则和里氏替换原则

缺点：

1. 类的数量容易过多
2. 增加了系统的抽象度
3. 抽象产品只能生产出一种产品，此弊端可以用抽象工厂模式解决

应用场景：

1. 客户只知道创建产品的工厂名，而不知道具体的产品名
2. 创建对象的任务由多个具体子工厂中的一个完成，而抽象工厂只提供创建产品的接口
3. 客户不关心产品细节，只关心产品品牌

模式结构：

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的newProduct方法创建对象
2. 具体工厂（ConcreteFactory）：实现抽象工厂中的方法，完成具体对象的创建
3. 抽象产品（Product）：定义产品规范，描述产品特征
4. 具体产品（ConcreteProduct）：实现抽象产品接口，由具体工厂来生产，和具体工厂之间一一对应

实现：

/**
 * @Author: KenChen
 * @Description: 普通工厂模式示例
 * @Date: Create in  2022/5/12 11:48
 */
public class AbstractFactoryTest {

    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteProduct1Factory();
        AbstractFactory factory2 = new ConcreteProduct2Factory();
        Product product = factory1.makeProduct();
        Product product2 = factory2.makeProduct();
        product.show();
        product2.show();
    }

    //    抽象产品类，提供接口方法
    interface Product {
        void show();
    }

    //    具体产品类
    static class ConcreteProduct1 implements Product {

        @Override
        public void show() {
            System.out.println("具体产品1");
        }
    }

    static class ConcreteProduct2 implements Product {

        @Override
        public void show() {
            System.out.println("具体产品2");
        }
    }

    //    抽象工厂接口
    interface AbstractFactory {
        Product makeProduct();
    }

    static class ConcreteProduct1Factory implements AbstractFactory{

        @Override
        public Product makeProduct() {
            System.out.println("工厂1生产--------> 产品1");
            return new ConcreteProduct1();
        }
    }

    static class ConcreteProduct2Factory implements AbstractFactory{

        @Override
        public Product makeProduct() {
            System.out.println("工厂2生产--------> 产品2");
            return new ConcreteProduct2();
        }
    }
}