Kotlin工厂模式

工厂模式的核心作用就是通过一个工厂类隐藏对象实例的创建。典型的应用是一个父类多个子类。

 

通过伴生对象创建静态工厂方法

 

interface Computer {
    val cpu: String

    companion object Factory {
        operator fun invoke(type: Type): Computer {
            return when (type) {
                Type.PC -> PC()
                Type.Server -> Server()
            }
        }
    }
}

enum class Type {
    PC, Server
}

class PC(override val cpu: String = "Core") : Computer
class Server(override val cpu: String = "Server") : Computer

fun main() {
    Computer.Factory(Type.PC)
    Computer.Factory(Type.Server)
}

 

抽象工厂为创建一组相关或互相依赖的对象提供一个接口，无需指定它们的具体类

 

内联函数简化抽象工厂

 

sealed class Computer {
    abstract val cpu: String

    class Apple(override val cpu: String = "Core") : Computer()
    class IBM(override val cpu: String = "Server") : Computer()
}

class AppleFactory : AbstractFactory() {
    override fun produce(): Computer = Computer.Apple()
}

class IBMFactory : AbstractFactory() {
    override fun produce(): Computer = Computer.IBM()
}

abstract class AbstractFactory {
    abstract fun produce(): Computer

    companion object {
        inline operator fun <reified T : Computer> invoke(): AbstractFactory {
            return when (T::class) {
                Computer.Apple::class -> AppleFactory()
                Computer.IBM::class -> IBMFactory()
                else -> throw IllegalArgumentException()
            }
        }
    }
}

 

参考：kotlin核心编程

 

 https://github.com/dbacinski/Design-Patterns-In-Kotlin/#visitor