工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品。抽象工厂模式是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。

抽象工厂模式是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

下面给出抽象工厂的实例：

假设现在有一个工厂可以生产一些产品（手机、电脑、飞机），另一个工厂可以对生产出来的产品上色（红色、绿色、彩虹色）。我们通过抽象工厂的方式来实现具体工厂的创建，以及产品的生产。

1. 创建一个接口Product

这个接口表示一种产品（手机、电脑、飞机），但具体是什么我们并不知道。
接口中声明一个方法，表示生产一个产品。

//产品接口
public interface Product {
    void product();
}

2. 创建Product接口的实现类

三个实现类Phone、Computer、Plane分别表示手机、电脑、飞机这三种产品。

//手机类
public class Phone implements Product {
    @Override
    public void product() {
        System.out.println("生产了一个牛逼的智能手机");
    }
}

//电脑类
public class Computer implements Product {
    @Override
    public void product() {
        System.out.println("生产了一台程序员都想要的电脑");
    }
}

//飞机类
public class Plane implements Product {
    @Override
    public void product() {
        System.out.println("生产了一架飞机，随时带你起飞");
    }
}

3. 创建另一个接口Color

这个接口表示不同的颜色（红色、绿色、彩色），
接口中声明一个方法表示给产品赋予一种颜色。

//颜色接口
public interface Color {
    void coloring();
}

4. 创建Color接口的实现类

三个实现类Red、Green、Rainbow分别表示三种不同的颜色（红色、绿色、彩色）。

//红色
public class Red implements Color {
    @Override
    public void coloring() {
        System.out.println("为产品增添了一层中国红");
    }
}

//绿色
public class Green implements Color {
    @Override
    public void coloring() {
        System.out.println("为产品赋予大自然之绿");
    }
}

//彩虹色
public class Rainbow implements Color {
    @Override
    public void coloring() {
        System.out.println("五彩斑斓，那是彩虹的颜色");
    }
}

5. 为 Color 和 Product对象创建抽象工厂AbstractFactory 来获取工厂

可以通过抽象工厂获取具体的产品工厂和颜色工厂

//抽象工厂类
public abstract class AbstractFactory {
    //生产产品的工厂
    public abstract Product createProduct(String productType);

    //为产品上色的工厂
    public abstract Color drawColor(String colorType);
}

6. 创建抽象工厂 AbstractFactory 的实现类，基于给定的信息生成实体类的对象。

ProductFactory是生产产品的工厂，用户生产出手机、电脑和飞机。
ColorFactory 是颜色工厂，用来给产品上色。

//生产产品的工厂
public class ProductFactory extends AbstractFactory {
    @Override
    public Product createProduct(String productType) {
        if(productType.equals("手机")){
            return new Phone();
        }else if(productType.equals("电脑")){
            return new Computer();
        }else if(productType.equals("飞机")){
            return new Plane();
        }else {
            System.out.println("传入产品类型有误！");
        }
        return null;
    }

    @Override
    public Color drawColor(String colorType) {
        return null;
    }
}

//产品上色的工厂
public class ColorFactory extends AbstractFactory {
    @Override
    public Product createProduct(String productType) {
        return null;
    }

    @Override
    public Color drawColor(String colorType) {
        if(colorType.equals("红色")){
            return new Red();
        }else if(colorType.equals("绿色")){
            return new Green();
        }else if(colorType.equals("彩虹色")){
            return new Rainbow();
        }else {
            System.out.println("传入产品类型有误！");
        }
        return null;
    }
}

7. 创建一个工厂创造器/生成器类，来获取具体工厂。

//工厂生成器
public class FactoryProducer {
    public static AbstractFactory getFactory(String type){
        if(type.equals("产品厂")){
            return new ProductFactory();
        } else if(type.equals("颜色厂")){
            return new ColorFactory();
        }
        return null;
    }
}

8. 使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

用过抽象工厂创建出两个具体工厂，在通过具体工厂生产出产品和颜色对象。

public class FactoryMain {
    public static void main(String[] args) {
        //获取生产产品的工厂
        AbstractFactory product = FactoryProducer.getFactory("产品厂");
        //获取增加颜色的工厂
        AbstractFactory color = FactoryProducer.getFactory("颜色厂");

        //生产一部手机
        Product phone = product.createProduct("手机");
        phone.product();
        //为手机上色
        Color red = color.drawColor("红色");
        red.coloring();

    }
}

便于理解，下面给出几个类的关系图：