本文属于系列文章《设计模式》，附上文集链接
不知道看上一篇的时候，有没有看到一个问题，如果只是简单的工厂，为什么要一个抽象工厂类？那个抽象类完全没必要啊，直接用一个工厂类，传入class参数，不就行了吗？这里就来了，抽象工厂模式。不过说实话，抽象得我快抽风了。。看了几篇博客了，最后发现百度百科很强。

抽象工厂模式

• 定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。
• 作用：当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
• 是一个创建类模式

上面的定义和作用分别从书上和百度百科看到的，说实话，我并不是很懂，看了好几篇博客，结合百度百科，我决定这篇写成一篇可能会被人骂的文章。

首先还是上代码，上看到个人觉得不恰当的例子的代码：
大体是模仿工厂制造车吧

// 车接口
public interface CarModel {
    public void alarm();
    public void run();
}
// 实现CarModel接口的抽象车
public abstract class BenzCar implements CarModel{
    @Override
    public void alarm() {
        System.out.println("这是奔驰车");
    }
}
// 实现CarModel接口的抽象车
public abstract class BmwCar implements CarModel{
    @Override
    public void alarm() {
        System.out.println("这是宝马车");
    }
}
// A系列的奔驰车
public class ABenzCar extends BenzCar{
    @Override
    public void run() {
        System.out.println("A系列的奔驰车在飞驰");
    }
}
// A系列的宝马车
public class ABmwCar extends BmwCar{
    @Override
    public void run() {
        System.out.println("A系列的宝马车在飞驰");
    }
}
// 还有B系列的车，是有两个产品等级的，这里就不列出来了
// 抽象工厂
public abstract class AbstractCarFactory {
    // 为什么不能用泛型约束？
    // 因为用了泛型约束，就无法建立这个抽象对象，抽象工厂也就不复存在，为什么会建立不了这个抽象工厂呢？
    // 因为建立抽象工厂后，子类继承之后，抽象方法接收的参数并不是某一个具体的产品的class属性，这意味着，只要是符合这个类约束的子类的class属性，都可以传进来，这就没有不同工厂这种概念了，所以抽象工厂也不存在，因为一个工厂就处理完了。
//  public abstract <T extends BenzCar> T  getBenzCar(Class<T> c);
//  public abstract  <T extends BmwCar> T  getBmwCar(Class<T> c);
    public abstract BenzCar getBenzCar();
    public abstract BmwCar getBmwCar();
}
// 具体工厂
public class ACarFactory extends AbstractCarFactory {
    @Override
    public BenzCar getBenzCar() {
        ABenzCar car = new ABenzCar();
        // doSomething
        return car;
    }
    @Override
    public BmwCar getBmwCar() {
        ABmwCar car = new ABmwCar();
        // doSomething
        return car;
    }
    /*@Override
    public <T extends BenzCar> T getBenzCar(Class<T> c) {
        T car = null;
        try {
            car = (T) Class.forName(c.getName()).newInstance();
            return car;
        } catch (Exception e) {
        }
        return car;
    }*/
}
//场景类
public class Client {
    public static void main(String[] args) {
        ACarFactory aCarFactory = new ACarFactory();
        BenzCar abenzCar =  aCarFactory.getBenzCar();
        abenzCar.alarm();
        abenzCar.run();
        System.out.println("--------------------");
        BmwCar abmwCar = aCarFactory.getBmwCar();
        abmwCar.alarm();
        abmwCar.run();
        System.out.println("--------------------");
        BCarFactory bCarFactory = new BCarFactory();
        BenzCar bbenzCar = bCarFactory.getBenzCar();
        bbenzCar.alarm();
        bbenzCar.run();
        System.out.println("--------------------");
        BmwCar bbmwCar = bCarFactory.getBmwCar();
        bbmwCar.alarm();
        bbmwCar.run();
    }
}
结果：
这是奔驰车
A系列的奔驰车在飞驰
\--------------------
这是宝马车
A系列的宝马车在飞驰
\--------------------
这是奔驰车
B系列的奔驰车在飞驰
\--------------------
这是宝马车
B系列的宝马车在飞驰

来分析下代码，这段代码我觉得很有问题的地方，就在于抽象出那个AbstractCarFactory有什么用，为什么这么说？在抽象工厂那里的注释，我写上了，如果只是单纯地要划分产品等级，那我直接实现泛型约束，就像我注释掉
的代码。

public abstract <T extends BenzCar> T getBenzCar(Class<T> c);
public abstract <T extends BmwCar> T getBmwCar(Class<T> c);

这样的话，再建一个SuperFactory，超级工厂，根据传进来的class属性，就可以生产出相应的对象。可能有人会说，这个SuperFactory不符合单一职责原则啊，一个类做了多种事，好，那退而求次，选择两个类，分别生产A级产品和生产B级产品。然后就会有人说，那就对嘛，而两个生产的方法还是相同的，为了日后好扩展，抽象共同部分出来作为父类，超棒的。但是有没有想过，就像上面的代码，我可以换一种抽象方式，就是BenzCarFactory和BmwCarFactory，然后专门用来生产Benz和Bmw，还可以用泛型约束，方法都省了一个，这样有问题么？
就是因为有这样的疑问，所以就不敢乱写这篇东西，看了好几篇博客，结合书上的例子，看了下百度百科（这个真的强，可能就是用大神的博文做的），最后我得到了这样的一个理解：抽象工厂要解决的主要问题，是M个不同的产品族，M个产品族都有N个不同的等级，而每个等级的产品，都有共性！！！就是这个共性，才是使用抽象工厂的根本。

什么意思呢？用上文的代码来讲述，A系列的车和B系列的车，之所以要把它们分开两个工厂去实现，抽取出生产车的抽象方法，是因为A系列的车和B系列的车分别有A系列车的共性和B系列车的共性。就比如说，A系列的车在组装的时候要在方向盘那里铭一个“A”，B系列的车在组装的时候要在方向盘那里铭一个“B”，如果没用抽象工厂模式，用我上面那段话提的方法，要怎么实现呢？分别在BenzCarFactory和BmwCarFactory各自实现组装A字的方法和组装B字的方法。这样有啥不好呢？代码没重用呗，因为这两个方法都是一模一样的。还有一个问题，假设共性不止一个，而是有很多个，想想是不是很可怕。
而在抽象工厂怎么实现呢？在ACarFactory直接写A系列车共性的方法，在BCarFactory直接写B系列车共性的方法，这样就很完美了。

然后看完百度百科有点醍醐灌顶的时候，看到了一句话，在日常的编程中，工厂方法用得比抽象工厂要多！！！！好吧，给了我一记重锤。

以上，就是我对抽象工厂模式的理解。要打要骂评论区走起。