抽象工厂模式Abstract Factory

简介

有了工厂模式后，怎么还会有多一个抽象工厂呢。可以这么说，工厂模式算是抽象工厂的一个子类，而抽象工厂，可以有很多的子类。抽象工厂就是将工厂的方式抽成一个基类来。举个例子会更好一点。

举例

举一个汽车生产轮胎引擎的例子。我们先抽象出一个汽车工厂类。

public interface CarFactory {
    ITire createTire();   //创建轮胎
    IEngfine createEngfine();    //创建引擎
}

而轮胎和引擎的抽象为，这里假设轮胎分为普通轮胎和SUV轮胎，引擎也分为普通引擎和SUV引擎

public interface ITire {
    void trie();
}

public interface IEngfine {
    void engine();
}

他们的实现类为

public class NormalEngfine implements IEngfine {
    @Override
    public void engine() {
    }
}

public class NormalTire implements ITire {
    @Override
    public void trie() {
    }
}

public class SUVEngfine implements IEngfine {
    @Override
    public void engine() {
    }
}

public class SUVTire implements ITire {
    @Override
    public void trie() {
    }
}

现在，假定我要生产一个普普通通的配件，也就是普通轮胎和普通引擎，现在，我创建一个普通工厂类专门来生产

public class NormalFactory implements CarFactory{
    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngfine createEngfine() {
        return new NormalEngfine();
    }
}

如果我要生产SUV配件，也就是SUV轮胎和SUV引擎，就可以创建个SUVFactory

public class SUVFactory implements CarFactory {
    @Override
    public ITire createTire() {
        return new SUVTire();
    }

    @Override
    public IEngfine createEngfine() {
        return new SUVEngfine();
    }
}

有人可能就会问啦，为什么要这样啊，创建两个子类出来搞，为什么不直接一个类，然后根据类型去获取对应的型号呢，也就是

public class GeneralFactory implements CarFactory {
    @Override
    public ITire createTire(int type) {
        switch (type)
        {
            case 0:return new NormalTire();
            case 1:return new SUVTire();
        }
        return null;
    }

    @Override
    public IEngfine createEngfine(int type) {
        switch (type)
        {
            case 0:return new NormalEngfine();
            case 1:return new SUVEngfine();
        }
        return null;
    }
}

当然，从实现的角度上看，结果肯定是可行的，但是扩展性太差了，如果此时我想要再添加一个生产普通排气管，普通轮胎，普通引擎的方法，你是不要要在GeneralFactory更改Type,以及每一个方法。如果我又想要生产普通方向盘，手柄这些呢。如果用了抽象工厂的话，只需要继承现有工厂类就可以实现扩展了，扩展性就比较好。

当然抽象工厂方法弊端也有, 不仅需要扩展新的 工厂类 还要扩展 新的组件类 。