创建型模式 - 抽象工厂简化

我们有很多电脑的品牌，如：Dell，Asus,Acer 那么就需要在增加一个工厂类，然而我们并不希望对每个模型简历一个工厂。这个时候需要用到抽象工厂。

内联函数简化抽象工厂

抽象工厂，----》把一组相关或者依赖的对象---产品族。

最直白的创建

interface Computer
class Dell:Computer
class Acer:Computer
class Asus:Computer

abstract class AbstractFactory{
    abstract fun produce():Computer
           companion object {
            operator fun invoke(factory:AbstractFactory):AbstractFactory{
                return factory
            }
        }
}

class DellFactory:AbstractFactory(){
    override fun produce():Computer = Dell()
}
class AsusFactory:AbstractFactory(){
    override fun produce():Computer = Asus()
}
class AcerFactory:AbstractFactory(){
    override fun produce():Computer = Acer()
}

fun main() {
    val dellFactory = AbstractFactory(DellFactory())
    println(dellFactory)
}

用Kotlin内联函数改造

1. inline 创建invoke内联函数
2. reifield 参数具体化，使用泛型创建

/**
 * inline 将invoke定义为内联函数，引入reified，使用具体话参数类型
 * 要具体化参数类型Computer，invoke判断Computer类型
 */
abstract class AbstractFactory {
    abstract fun produce(): Computer


    companion object {
        inline operator fun <reified T : Computer> invoke(): AbstractFactory =
            when (T::class) {
                Dell::class -> DellFactory()
                Asus::class -> AsusFactory()
                Acer::class -> AcerFactory()
                else -> throw IllegalArgumentException()
            }
    }
}
  fun main() {
    val dellFactory = AbstractFactory<Dell>()
    val dell = dellFactory.produce()
    println(dell)

}