抽象工厂模式就相当于是工厂的工厂模式，是围绕一个超级工厂去创建其他工厂。这种类型的设计模式属于创建型模式。它的优点是1：当一个产品族中的多个对象被设计成一起工作时，他能保证客户端始终只使用一个产品族中的对象缺点是1：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的Creator中增加代码，又要在具体里增加代码。

例：1.为形状创建一个接口

interface Shape{
    fun draw()
}

2.创建实现接口的实体类

class Rectangle: Shape{
    override fun draw() {
        println("Rectangle")
    }
}
class Circle: Shape{
    override fun draw() {
        println("Circle")
    }
}

3.为颜色创建一个接口

interface Color{
    fun fill()
}

4.创建实现接口的实体类

class Red: Color{
    override fun fill() {
        println("Red")
    }
}
class Green: Color{
    override fun fill() {
        println("Green")
    }
}

5.为Color和Shape对象创建抽象类来获取工厂

abstract class AbstractFactory{
    abstract fun getShape(s: String): Shape
    abstract fun getColor(s: String): Color
}

6.创建扩展了AbstractFactory的工厂类，基于给定的信息生成实体类的对象

class ShapeFactory: AbstractFactory() {
    override fun getShape(s: String): Shape {
        if (s == "Circle") return Circle()
        else if (s == "Rectangle") return Rectangle()
        else return object : Shape{
            override fun draw() {
                println("null")
            }
        }
    }
    override fun getColor(s: String): Color {
        TODO("Not yet implemented")
    }
}
class ColorFactory: AbstractFactory(){
    override fun getColor(s: String): Color {
        if (s == "Red") return Red()
        else if (s == "Green") return Green()
        else return object : Color{
            override fun fill() {
                println("null")
            }
        }
    }

    override fun getShape(s: String): Shape {
        TODO("Not yet implemented")
    }
}

7.创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂

class FactoryProducer{
    fun getFactory(s: String): AbstractFactory{
        if (s == "Shape") return ShapeFactory()
        else if (s == "Color") return ColorFactory()
        else return object : AbstractFactory(){
            override fun getShape(s: String): Shape {
                TODO("Not yet implemented")
            }

            override fun getColor(s: String): Color {
                TODO("Not yet implemented")
            }

        }
    }
}

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

fun main(){
    val colorfactory = FactoryProducer().getFactory("Color")
    colorfactory.getColor("Red").fill()
    val shapefactory = FactoryProducer().getFactory("Shape")
    shapefactory.getShape("Circle").draw()
}

9.执行程序，输出结果