如前面所说，工厂方法模式只考虑生产同种等级的产品，比如造车的工厂就只是造车，生产手机的工厂就只是生产手机，但是在我们的现实生活中，许多工厂是综合性的工厂，比如造车的工厂也能造手机。为啥这么设计呢？用工厂方法不是更好吗，想造手机，再建一个造手机的工厂不就行了吗？用毛爷爷的话说，理论上行得通，但实际上不可行，因为现在的很多公司都是综合性的公司，大公司会生产各种各样的产品，要是每种产品就建一个工厂，那么地球上的土地就这么点，哪里够用呀，所以综合性工厂可以解决这个问题。这里我们以造车的例子为基础，为工厂新增一个造手机的功能。类图如下：

抽象工厂模式代码实现

基于工厂方法的例子，我们新增一个产品手机，首先定义手机的公共接口：

public interface IPhone {
    // 刷上颜色
    void printColor();

    // 安装系统
    void installOS();
}

创建手机A

public class PhoneA implements IPhone{
    private String color;
    private String systemOs;
    @Override
    public void printColor() {
        System.out.println("粉刷手机颜色为红色");
        color = "RED";

    }

    @Override
    public void installOS() {
        System.out.println("安装手机的操作系统为Android系统");
        systemOs = "Android";
    }

    @Override
    public String toString() {
        return "PhoneA{" +
                "color='" + color + '\'' +
                ", systemOs='" + systemOs + '\'' +
                '}';
    }
}

创建手机B：

public class PhoneB implements IPhone{
    private String color;
    private String systemOs;
    @Override
    public void printColor() {
        System.out.println("粉刷手机颜色为蓝色");
        color = "BLUE";

    }

    @Override
    public void installOS() {
        System.out.println("安装手机的操作系统为IOS系统");
        systemOs = "IOS";
    }

    @Override
    public String toString() {
        return "PhoneB{" +
                "color='" + color + '\'' +
                ", systemOs='" + systemOs + '\'' +
                '}';
    }
}

然后我们定义我们要建的综合性工厂的标准接口

public interface IAbstractFactory {
    ICar buildCar();
    IPhone buildPhone();
}

新建两个综合性工厂，A和B，分别生产A品牌的产品和B品牌的产品。

// 生产A品牌的产品
public class AFactory implements IAbstractFactory {
    private ICar mCarA =new  CarA();
    private IPhone mPhoneA = new PhoneA();
    @Override
    public ICar buildCar() {
        mCarA.printColor();
        mCarA.installEngine();
        mCarA.installWheels();
        mCarA.installSystem();
        return mCarA;
    }

    @Override
    public IPhone buildPhone() {
        mPhoneA.printColor();
        mPhoneA.installOS();
        return mPhoneA;
    }
}

// 生产B品牌的产品
public class BFactory implements IAbstractFactory {
    private ICar mCarB =new CarB();
    private IPhone mPhoneB = new PhoneB();
    @Override
    public ICar buildCar() {
        mCarB.printColor();
        mCarB.installEngine();
        mCarB.installWheels();
        mCarB.installSystem();
        return mCarB;
    }

    @Override
    public IPhone buildPhone() {
        mPhoneB.printColor();
        mPhoneB.installOS();
        return mPhoneB;
    }
}

抽象工厂的使用方法

我们新建一个Client的类来演示抽象工厂的使用方法

public class Client {
    public static void main(String[] args) {
        // 抽象工厂
        IAbstractFactory mAFactory = new AFactory();
        ICar myAcar = mAFactory.buildCar();
        IPhone myAPhone = mAFactory.buildPhone();
        System.out.println("A工厂造的车: " + myAcar);
        System.out.println("A工厂造的手机: " + myAPhone);

        IAbstractFactory mBFactory = new BFactory();
        ICar myBcar = mBFactory.buildCar();
        IPhone myBPhone = mBFactory.buildPhone();
        System.out.println("B工厂造的车: " + myBcar);
        System.out.println("B工厂造的手机: " + myBPhone);
    }
}

运行结果：

抽象工厂模式的应用场景

当需要生产多种产品的时候，比如我们的工厂需要造车和造手机时，可以考虑使用抽象工厂模式，比如我们的电器厂，就可以考虑使用抽象工厂模式，因为电器厂既可以生产电视机也能生产空调。，农场也是，农场可以种植物，也可以养动物。