刚刚的简单工厂模式只提供一种类别的产品，那么抽象工厂能实现多种产品组合。
简单工厂模式
假设我们不仅需要手机，还感觉口渴了，需要饮料怎么办呢。
首先定义一个饮料的接口。

public interface Drink {
    void provide();
}

具体实现类

public class BlackTea implements Drink{
    @Override
    public void provide() {
        System.out.println("提供红茶");
    }
}

public class GreenTea implements Drink{
    @Override
    public void provide() {
        System.out.println("提供绿茶");
    }
}

public class Cola implements Drink{
    @Override
    public void provide() {
        System.out.println("提供可乐");
    }
}

我们现在有两个产品线，手机和饮料。
我们先创建一个抽象工厂，抽象类需要有获取产品的方法。

public abstract class AbstractFactory {
    public abstract Phone getPhone(String phoneType);
    public abstract Drink getDrink(String drinkType);
}

然后创建具体的工厂类，继承上面的抽象类。

public class DrinkFactory extends AbstractFactory{

    @Override
    public Phone getPhone(String phone) {
        return null;
    }

    @Override
    public Drink getDrink(String drinkType){
        if (drinkType ==null){
            return null;
        }
        if (drinkType.equalsIgnoreCase("BlackTea")){
            return new BlackTea();
        }else if (drinkType.equalsIgnoreCase("GreenTea")){
            return new GreenTea();
        }else if (drinkType.equalsIgnoreCase("Cola")){
            return new Cola();
        }else
            return null;
    }
}

public class PhoneFactory extends AbstractFactory{

    @Override
    public Phone getPhone(String phoneType){
        if (phoneType ==null){
            return null;
        }
        if (phoneType.equalsIgnoreCase("XiaoMi")){
            return new XiaoMi();
        }else if (phoneType.equalsIgnoreCase("HuaWei")){
            return new HuaWei();
        }else if (phoneType.equalsIgnoreCase("ViVo")){
            return new ViVo();
        }else
            return null;
    }

    @Override
    public Drink getDrink(String drinkType) {
        return null;
    }
}

这里新建一个工厂提供类进行工厂的创建。

public class FactoryProducer {
    public static AbstractFactory getFactory(String type){
        if (type.equalsIgnoreCase("Phone")){
            return new PhoneFactory();
        }else if (type.equalsIgnoreCase("Drink")){
            return new DrinkFactory();
        }
        return null;
    }
}

测试用例

public static void main(String[] args) {
        AbstractFactory drinkFactory = FactoryProducer.getFactory("drink");
        Drink cola = drinkFactory.getDrink("Cola");
        cola.provide();
        AbstractFactory phoneFactory = FactoryProducer.getFactory("phone");
        Phone xiaomi = phoneFactory.getPhone("xiaomi");
        xiaomi.brand();
    }

通过抽象工厂就能进行产品线的组合。