抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
    在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

    就是把工厂模式的Factory再抽象一层，用来创建各种各样的工厂。

    使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。
    注意事项**：产品族难扩展，产品等级易扩展。

    接着工厂模式代码, 现在汽车的窗户也是接口，可以由不同的厂家来生成汽车的窗户。如A厂家 B厂家

    1. public interface CarWindow {
    2.     void run();
    3. }
    5. public class ACarWindow implements  CarWindow{
    6.     public void run() {
    7.         System.out.println("A 品牌的窗户！");
    8.     }
    9. }
    11. public class BCarWindow implements CarWindow{
    12.     public void run() {
    13.         System.out.println("B 品牌的窗户！");
    14.     }
    15. }

    然后再抽象一个抽象工厂出来，来生产不同的工厂，汽车工厂和汽车窗户工厂。

    1. public abstract class AbstractFatory {
    2.     public abstract CarWindow getCarWindow(int type);
    3.     public abstract Car getCar(int type);
    4. }
    7. public class CarFactory2 extends AbstractFatory{
    8.     public CarWindow getCarWindow(int type) {
    9.         return null;
    10.     }
    12.     /**
    13.      * carType可以写在配置文件中  用枚举代替
    14.      * @param carType
    15.      */
    16.     public Car getCar(int carType){
    17.         Car car = null;
    18.         if(carType == CarEnum.BT_CAR.getVal()){
    19.             car = new BTCar();
    20.         }else if(carType == CarEnum.BM_CAR.getVal()){
    21.             car = new BMCar();
    22.         }else if(carType == CarEnum.BZ_CAR.getVal()){
    23.             car = new BZCar();
    24.         }
    25.         return car;
    26.     }
    27. }
    29. public class CarWindowFactory extends AbstractFatory {
    30.     public CarWindow getCarWindow(int windowType) {
    31.         CarWindow carWindow = null;
    32.         if(windowType == 1){
    33.             carWindow = new ACarWindow();
    34.         }else if(windowType == 2){
    35.             carWindow = new BCarWindow();
    36.         }
    37.         return carWindow;
    38.     }
    40.     public Car getCar(int carType) {
    41.         return null;
    42.     }
    43. }

    然后再有不同的实现来生产具体的工厂

    1. public class FactoryProducer {
    2.     public static AbstractFatory getFactory(String choice){
    3.         if(choice.equalsIgnoreCase("CAR")){
    4.             return new CarFactory2();
    5.         } else if(choice.equalsIgnoreCase("WINDOW")){
    6.             return new CarWindowFactory();
    7.         }
    8.         return null;
    9.     }
    10. }

    启动测试主函数

    1. public static void main(String[] args) {
    2.     AbstractFatory carFactory = FactoryProducer.getFactory("CAR");
    3.     carFactory.getCar(1).run();
    5.     AbstractFatory windowFactory = FactoryProducer.getFactory("WINDOW");
    6.     windowFactory.getCarWindow(1).run();
    7. }

    总结：就是工厂模式使用的时候，一个大的工厂可以代替生产窗户 ，坐垫，椅子 等等其他的小的工厂。使用一个工厂就可以解决。